index.xml

<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Ashwin Narayan</title>
    <link>https://www.ashwinnarayan.com/</link>
      <atom:link href="https://www.ashwinnarayan.com/index.xml" rel="self" type="application/rss+xml" />
    <description>Ashwin Narayan</description>
    <generator>Source Themes Academic (https://sourcethemes.com/academic/)</generator><language>en-us</language><copyright>© 2020 Ashwin Narayan</copyright><lastBuildDate>Sun, 06 Oct 2024 20:04:51 +0800</lastBuildDate>
    <image>
      <url>https://www.ashwinnarayan.com/images/icon_hu0b7a4cb9992c9ac0e91bd28ffd38dd00_9727_512x512_fill_lanczos_center_3.png</url>
      <title>Ashwin Narayan</title>
      <link>https://www.ashwinnarayan.com/</link>
    </image>
    
    <item>
      <title>Writing a small async runtime for Cortex-M micro-controllers with Rust</title>
      <link>https://www.ashwinnarayan.com/post/embedded-async-with-rust/</link>
      <pubDate>Sun, 06 Oct 2024 20:04:51 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/embedded-async-with-rust/</guid>
      <description>&lt;h2 id=&#34;introduction&#34;&gt;Introduction&lt;/h2&gt;
&lt;p&gt;I&amp;rsquo;ve been working with Rust on microcontrollers for a while now, and I&amp;rsquo;ve been using the excellent embassy crate for async programming. However, I recently started using a processor for which embassy does not have Hardware Abstraction Layer (HAL) support, and I wanted to experiment with building my own async runtime. This was also a great opportunity to learn more about the processor and understand the implementation details of async/await in Rust.&lt;/p&gt;
&lt;p&gt;In this article, we&amp;rsquo;ll create an async runtime for ARM Cortex-M microcontrollers. We&amp;rsquo;ll build on Philipp Oppermann&amp;rsquo;s work for x86 bare-metal systems here and adapt the approach for Cortex-M, which presents unique challenges like limited memory and often lacking a Memory Management Unit (MMU). These constraints require different design choices for async primitives, executors, and interrupt handling.&lt;/p&gt;
&lt;p&gt;Note that this is an experimental project focused on learning and exploration. It is not production-ready, but it serves as a good starting point for building your own async runtime for embedded systems. If you&amp;rsquo;re looking for mature libraries for running real-time code on embedded systems, consider using 
&lt;a href=&#34;https://embassy.dev&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;embassy&lt;/a&gt; or 
&lt;a href=&#34;https://rtic.rs&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;rtic&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;We will cover:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Building a lightweight executor for embedded systems&lt;/li&gt;
&lt;li&gt;Implementing tasks in an async context&lt;/li&gt;
&lt;li&gt;Utilizing power-saving features to sleep the microcontroller when no tasks are active&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;By the end of this article, you&amp;rsquo;ll understand the basics of creating a custom async runtime and how it can be adapted to a resource-constrained environment like Cortex-M microcontrollers.&lt;/p&gt;
&lt;h2 id=&#34;why-build-your-own-async-runtime&#34;&gt;Why Build Your Own Async Runtime?&lt;/h2&gt;
&lt;p&gt;Building an async runtime from scratch is not just a fun exercise but a useful way to understand how embedded systems handle concurrent tasks. This is particularly important for real-time systems that need to manage limited resources, such as processing power and memory. You&amp;rsquo;ll also be forced to become familiar with the inner workings the underlying hardware peripherals on the microcontroller and how they interact with the runtime. In a world where abstractions are stacked liberally and the typical developer is separated from the hardware by multiple layers of abstraction, this exercise can be a refreshing change of pace.&lt;/p&gt;
&lt;p&gt;With existing libraries like Embassy, you can quickly get started with async programming on supported hardware. However, there might be scenarios where support for specific hardware is not available, or you need more control over how tasks are managed. This article aims to bridge that gap by helping you understand what it takes to write a custom runtime for such cases.&lt;/p&gt;
&lt;h2 id=&#34;what-is-async-programming&#34;&gt;What is Async Programming?&lt;/h2&gt;
&lt;p&gt;In Rust, async/await allows you to write asynchronous code that looks very similar to synchronous code. It allows you to write code that can pause and resume execution without blocking the entire system, which is particularly useful for handling tasks like I/O operations, waiting for timers, or running multiple concurrent tasks.&lt;/p&gt;
&lt;p&gt;The async model in Rust uses cooperative multitasking, where tasks yield control back to the executor when they are waiting for something to happen. This is different from preemptive multitasking, where an operating system controls task switching. Cooperative multitasking has the advantage of being predictable and having lower overhead, but it requires each task to explicitly yield control and be well-behaved.&lt;/p&gt;
&lt;p&gt;For embedded systems, cooperative multitasking often works well because it keeps the system simple and avoids the overhead of complex task switching, which is critical when working with constrained environments like microcontrollers.&lt;/p&gt;
&lt;h2 id=&#34;how-async-works-in-rust&#34;&gt;How Async Works in Rust&lt;/h2&gt;
&lt;p&gt;In Rust, async functions implement the Future trait. Futures can be polled using the poll() method. If a future is ready to produce a value, it returns Poll::Ready(T); otherwise, it returns Poll::Pending. The executor is responsible for polling these futures and managing the lifecycle of tasks.&lt;/p&gt;
&lt;p&gt;The executor works by polling each task until it completes. It acts as the &amp;ldquo;runtime&amp;rdquo; that runs the tasks concurrently and keeps them progressing. For more details on how this works, I recommend checking out 
&lt;a href=&#34;https://os.phil-opp.com/async-await&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Phil Oppermann&amp;rsquo;s blog&lt;/a&gt;.&lt;/p&gt;
&lt;h2 id=&#34;async-execution-workflow&#34;&gt;Async Execution Workflow&lt;/h2&gt;
&lt;p&gt;Below is a visual representation of how an async executor manages tasks and keeps polling them until completion.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-mermaid&#34;&gt;graph TD
  subgraph Executor
    A[Task Queue] --&amp;gt; B[Task Polling]
  end

  subgraph Task
    D[Future] --&amp;gt; E[Poll Function]
  end

  A --&amp;gt; F[Task Scheduler]
  F --&amp;gt; E
  E --&amp;gt; G{Poll Result}
  G --&amp;gt;|Pending| F
  G --&amp;gt;|Ready| H[Complete Task]

  M[Sleep if Idle] --&amp;gt; F
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;This diagram shows how the executor maintains a queue of tasks, polls them to determine their state, and schedules them accordingly. If there are no tasks to execute, the executor can put the processor to sleep to save power.&lt;/p&gt;
&lt;h2 id=&#34;defining-a-task&#34;&gt;Defining a Task&lt;/h2&gt;
&lt;p&gt;Each task in our runtime is represented as a &lt;code&gt;Future&lt;/code&gt; pinned in memory, ensuring it can be polled without being moved. This is crucial because futures created by &lt;code&gt;async&lt;/code&gt;/&lt;code&gt;await&lt;/code&gt; may be self-referential, and moving them in memory would invalidate references to their internal fields.&lt;/p&gt;
&lt;p&gt;Embedded environments typically don&amp;rsquo;t have access to standard memory allocators, so we need to initialize a custom heap allocator. We&amp;rsquo;ll use the &lt;code&gt;embedded_alloc&lt;/code&gt; crate, which is designed for embedded systems. Below is the implementation of our task and how it uses atomic counters for task IDs.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-rust&#34;&gt;// Import the &#39;alloc&#39; crate, which provides memory allocation utilities. 
// Necessary for dynamic memory allocation in a no_std environment.
extern crate alloc;

// Importing &#39;Box&#39; from the &#39;alloc&#39; crate. Box is a smart pointer for heap-allocated memory.
use alloc::boxed::Box;
// Importing &#39;addr_of_mut&#39; from core::ptr to get the mutable pointer to the heap memory.
use core::ptr::addr_of_mut;
// Importing &#39;AtomicU32&#39; and &#39;Ordering&#39; to manage atomic operations in a multi-threaded or interrupt context.
use core::sync::atomic::{AtomicU32, Ordering};
// Importing essential types for async and future handling from core: Future, Pin, Context, and Poll.
use core::{
    future::Future,
    pin::Pin,
    task::{Context, Poll},
};
// Importing LlffHeap as Heap from &#39;embedded_alloc&#39; crate, which provides a memory allocator suitable for embedded systems.
use embedded_alloc::LlffHeap as Heap;

// Define a global allocator for heap memory. We use a static instance of Heap here.
#[global_allocator]
static HEAP: Heap = Heap::empty();  // The heap is initially empty and needs to be initialized.

/// Initialize the heap.
pub fn init_heap() {
    use core::mem::MaybeUninit;  // Use &#39;MaybeUninit&#39; to represent uninitialized memory safely.
    const HEAP_SIZE: usize = 1024;  // Define the size of the heap in bytes.
    
    // Allocate an uninitialized array of bytes (of type MaybeUninit&amp;lt;u8&amp;gt;), which will serve as the heap.
    static mut HEAP_MEM: [MaybeUninit&amp;lt;u8&amp;gt;; HEAP_SIZE] = [MaybeUninit::uninit(); HEAP_SIZE];
    
    // Initialize the heap using the starting address and size of the memory array. &#39;unsafe&#39; is required 
    // because we are using raw pointers and modifying static mutable data.
    unsafe { HEAP.init(addr_of_mut!(HEAP_MEM) as usize, HEAP_SIZE) }
}

/// Task ID type. We use a 32-bit unsigned integer to represent a task ID.
/// Cortex-M architecture is 32-bit, and it doesn&#39;t support atomic 64-bit integers.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
struct TaskId(u32);  // TaskId is a wrapper around a 32-bit unsigned integer.

impl TaskId {
    /// Generate a new unique task ID. 
    fn new() -&amp;gt; Self {
        static NEXT_ID: AtomicU32 = AtomicU32::new(0);  // Static AtomicU32 that stores the next available task ID.
        TaskId(NEXT_ID.fetch_add(1, Ordering::Relaxed))  // Increment and return the current ID.
    }
}

/// Base struct to represent a task.
pub struct Task {
    /// A unique identifier for the task.
    id: TaskId,  // Each task has a unique TaskId.
    /// The future representing the task. The Pin&amp;lt;Box&amp;lt;&amp;gt;&amp;gt; wrapper ensures that the
    /// future is not moved in memory. The Output type of the future is (), indicating
    /// that the future does not return a value - it just runs to completion.
    future: Pin&amp;lt;Box&amp;lt;dyn Future&amp;lt;Output = ()&amp;gt;&amp;gt;&amp;gt;,  // The &#39;Pin&#39; ensures that the future is pinned in memory and cannot be moved.
}

impl Task {
    /// Create a new task from a future.
    pub fn new(future: impl Future&amp;lt;Output = ()&amp;gt; + &#39;static) -&amp;gt; Task {
        Task {
            id: TaskId::new(),  // Assign a new unique TaskId to the task.
            future: Box::pin(future),  // Pin the future to ensure it is not moved in memory and store it in a Box.
        }
    }

    /// Poll the task. This checks whether the future is ready to make progress or has completed.
    /// &#39;poll&#39; uses a mutable reference to the task&#39;s future and a context to manage async execution.
    fn poll(&amp;amp;mut self, context: &amp;amp;mut Context) -&amp;gt; Poll&amp;lt;()&amp;gt; {
        self.future.as_mut().poll(context)  // Poll the pinned future and pass the provided Context.
    }
}

// A module declaration for &#39;executor&#39;, the runtime that manages task execution.
pub mod executor;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;In this implementation, &lt;code&gt;TaskId&lt;/code&gt; is used to uniquely identify each task, and we use a 32-bit atomic counter to generate these IDs. This approach avoids the overhead of locking and works well in a 32-bit environment like Cortex-M.&lt;/p&gt;
&lt;h2 id=&#34;implementing-the-executor&#34;&gt;Implementing the Executor&lt;/h2&gt;
&lt;p&gt;The executor is responsible for managing tasks and running them to completion. It uses a task queue to determine which tasks are ready to run, and a custom &lt;code&gt;TaskWaker&lt;/code&gt; to wake up tasks when they are ready to make progress.&lt;/p&gt;
&lt;p&gt;Below is an implementation of the executor that runs tasks in a loop, polling each until they are complete.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-rust&#34;&gt;extern crate alloc;

use super::*;
use alloc::collections::{BTreeMap, VecDeque};
use alloc::sync::Arc;
use alloc::task::Wake;
use core::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
use cortex_m::asm;
use crossbeam_queue::ArrayQueue;

// The custom waker struct for waking tasks.
struct TaskWaker {
    task_id: TaskId, // Unique identifier for the task.
    task_queue: Arc&amp;lt;ArrayQueue&amp;lt;TaskId&amp;gt;&amp;gt;, // Shared queue used to store task IDs ready to be executed.
}

impl TaskWaker {
    // Create a new waker instance for a given task.
    fn new(task_id: TaskId, task_queue: Arc&amp;lt;ArrayQueue&amp;lt;TaskId&amp;gt;&amp;gt;) -&amp;gt; Waker {
        Waker::from(Arc::new(TaskWaker {
            task_id,
            task_queue,
        }))
    }
    
    // Add the task to the task queue, making it ready to be polled again.
    fn wake_task(&amp;amp;self) {
        self.task_queue
            .push(self.task_id)
            .expect(&amp;quot;Task queue is full!&amp;quot;);
    }
}

impl Wake for TaskWaker {
    // Wakes the task by adding it back to the task queue.
    fn wake(self: Arc&amp;lt;Self&amp;gt;) {
        self.wake_task();
    }

    // Wake the task by reference, allowing it to be added to the task queue without consuming the waker.
    fn wake_by_ref(self: &amp;amp;Arc&amp;lt;Self&amp;gt;) {
        self.wake_task();
    }
}

/// Task executor that runs tasks to completion.
pub struct Executor {
    /// Map of tasks to be run, indexed by task ID.
    tasks: BTreeMap&amp;lt;TaskId, Task&amp;gt;,
    /// Queue holding task IDs that are ready to be executed.
    task_queue: Arc&amp;lt;ArrayQueue&amp;lt;TaskId&amp;gt;&amp;gt;,
    /// Cache for storing wakers for tasks that are currently running.
    waker_cache: BTreeMap&amp;lt;TaskId, Waker&amp;gt;,
}

impl Executor {
    /// Create a new executor with an empty task queue.
    pub fn new&amp;lt;const N: usize&amp;gt;() -&amp;gt; Executor {
        Executor {
            tasks: BTreeMap::new(),
            task_queue: Arc::new(ArrayQueue::new(N)), // Initialize task queue with a capacity of N.
            waker_cache: BTreeMap::new(),
        }
    }

    /// Add a new task to the executor.
    pub fn spawn(&amp;amp;mut self, task: Task) {
        let task_id = task.id;
        if self.tasks.insert(task_id, task).is_some() {
            panic!(&amp;quot;task with same ID already in tasks&amp;quot;);
        }
        self.task_queue.push(task_id).expect(&amp;quot;Task queue is full.&amp;quot;); // Add the task ID to the task queue.
    }

    /// Run all tasks that are ready to execute.
    fn run_ready_tasks(&amp;amp;mut self) {
        // Continuously pop task IDs from the task queue and run them.
        while let Some(task_id) = self.task_queue.pop() {
            // Retrieve the task using its task ID.
            let task = match self.tasks.get_mut(&amp;amp;task_id) {
                Some(task) =&amp;gt; task,
                None =&amp;gt; continue, // If the task doesn&#39;t exist, skip it.
            };

            // Retrieve or create a waker for the task.
            let waker = self
                .waker_cache
                .entry(task_id)
                .or_insert_with(|| TaskWaker::new(task_id, self.task_queue.clone()));

            // Create a new context from the waker.
            let mut context = Context::from_waker(waker);

            // Poll the task to determine if it is ready to make progress.
            match task.poll(&amp;amp;mut context) {
                Poll::Ready(()) =&amp;gt; {
                    // If the task is complete, remove it and its waker from the cache.
                    self.tasks.remove(&amp;amp;task_id);
                    self.waker_cache.remove(&amp;amp;task_id);
                }
                Poll::Pending =&amp;gt; {} // If the task is not complete, leave it in the task list.
            }
        }
    }

    /// Put the processor to sleep if there are no tasks to run.
    fn sleep_if_idle(&amp;amp;self) {
        cortex_m::interrupt::free(|_| {
            // If the task queue is empty, put the processor to sleep.
            if self.task_queue.is_empty() {
                asm::wfi(); // Wait for interrupt to wake up the processor.
            }
        });
    }

    /// Run the executor to completion, continuously executing tasks until none are left.
    pub fn run(&amp;amp;mut self) {
        loop {
            self.run_ready_tasks();
            self.sleep_if_idle();
        }
    }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The Executor structure maintains a map of tasks, a task queue, and cached wakers for tasks that are currently running. The run method continuously runs tasks until none are left, and the &lt;code&gt;sleep_if_idle&lt;/code&gt; method puts the processor to sleep when there are no tasks to execute. As mentioned 
&lt;a href=&#34;https://github.com/phil-opp/blog_os/discussions/1018#discussioncomment-863025&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;here&lt;/a&gt; the &lt;code&gt;wfi&lt;/code&gt; instruction can be used to wait for an event or interrupt.&lt;/p&gt;
&lt;h2 id=&#34;putting-it-all-together&#34;&gt;Putting it all together&lt;/h2&gt;
&lt;p&gt;Below is an example of how to put everything together to run a simple async task on a Cortex-M microcontroller.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-rust&#34;&gt;#![no_std]
#![no_main]

use cortex_m_asyncrt::os::{self, executor, init_heap, Task};
use cortex_m_rt::entry;
use cortex_m_semihosting::{dbg, hprintln};
// use panic_probe as _;
use panic_semihosting as _;

#[entry]
fn main() -&amp;gt; ! {
    init_heap();
    hprintln!(&amp;quot;Hello, worlds!&amp;quot;);
    // New executor that can run up to 32 tasks
    let mut executor = executor::Executor:: new::&amp;lt;64&amp;gt;();

    // Spawn a task
    executor.spawn(Task::new(example_task()));

    // Run the executor
    executor.run();

    // This code is unreachable because the executor.run() function runs tasks to completion.
    loop {}
}

async fn example_task() {
    // your code goes here
    let r = example_fn().await;

    hprintln!(&amp;quot;r = {}&amp;quot;, r);
}

async fn example_fn() -&amp;gt; u32 {
    42
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;If you run this code on QEMU you should see the following output:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-shell&#34;&gt;Timer with period zero, disabling
Hello, worlds!
r = 42
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;If you want to try this out yourself, you can use the &lt;code&gt;cortex-m-asyncrt&lt;/code&gt; crate on 
&lt;a href=&#34;https://crates.io/crates/cortex-m-asyncrt&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;crates.io&lt;/a&gt;. Version 0.1.0 of the crate is exactly as described in this article.&lt;/p&gt;
&lt;h2 id=&#34;real-world-use-cases-and-future-work&#34;&gt;Real-World Use Cases and Future Work&lt;/h2&gt;
&lt;p&gt;This async runtime could be applied to scenarios where you need a lightweight scheduler for real-time tasks, such as sensor data collection, motor control, or communication handling in resource-constrained embedded systems.&lt;/p&gt;
&lt;p&gt;Future improvements could include adding task priority, enhancing the scheduler with time measurements for scheduling tasks at regular intervals and for asynchronously &lt;code&gt;await&lt;/code&gt;ing delays.&lt;/p&gt;
&lt;h2 id=&#34;references&#34;&gt;References&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;a href=&#34;https://os.phil-opp.com/async-await&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Philipp Oppermann&amp;rsquo;s blog on async/await&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://embassy.dev&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;embassy&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://rtic.rs&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;rtic&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://crates.io/crates/cortex-m-asyncrt&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;cortex-m-asyncrt crate&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;
</description>
    </item>
    
    <item>
      <title>Blinking LEDs with Rust</title>
      <link>https://www.ashwinnarayan.com/post/embedded-rust-blinking-led/</link>
      <pubDate>Thu, 02 May 2024 15:38:20 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/embedded-rust-blinking-led/</guid>
      <description>&lt;p&gt;Rust is a modern programming language focused on safety, speed, and concurrency. It&amp;rsquo;s a go-to for system-level tasks, offering strong guarantees against common bugs like null pointer dereferences. Embedded systems, with their resource constraints and real-time demands, could really benefit from more Rust. Rust&amp;rsquo;s zero-cost abstractions maintain performance while keeping code size small. Real-time requirements are met through precise hardware interaction, aided by Rust&amp;rsquo;s features like immutable variables and robust type systems. With cross-compilation capabilities and a growing library ecosystem, Rust has recently become (in my opinion) a viable choice for embedded development.&lt;/p&gt;
&lt;p&gt;Rust is also the first new programming language that I&amp;rsquo;ve learned since Haskell and I really like how it combines the best of functional programming with the best of systems programming. I&amp;rsquo;ve been playing around with Rust for a while now and I wanted to try my hand at embedded development with Rust. In this post, I&amp;rsquo;ll show you how to blink an LED on an STM32F407 Discovery board using Rust.&lt;/p&gt;
&lt;h2 id=&#34;the-stm32f407-discovery-board&#34;&gt;The STM32F407 Discovery Board&lt;/h2&gt;
&lt;p&gt;The 
&lt;a href=&#34;https://www.st.com/en/evaluation-tools/stm32f4discovery.html&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;STM32F407 Discovery&lt;/a&gt; board is a development board based on the STM32F407VG microcontroller. The board uses an STM32F407 micro-controller and has plenty of LEDs, some push buttons, an accelerometer, a microphone and an audio DAC. Plenty of peripherals to play around with. The 
&lt;a href=&#34;https://www.st.com/resource/en/user_manual/um1472-discovery-kit-with-stm32f407vg-mcu-stmicroelectronics.pdf&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;user manual&lt;/a&gt; has the pinouts and list of peripherals.&lt;/p&gt;
&lt;h2 id=&#34;setting-up-rust-for-embedded-development&#34;&gt;Setting Up Rust for Embedded Development&lt;/h2&gt;
&lt;p&gt;First follow the instructions from 
&lt;a href=&#34;https://rustup.rs&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;rustup.rs&lt;/a&gt; to install rust.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;curl --proto &#39;=https&#39; --tlsv1.2 -sSf https://sh.rustup.rs | sh
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;To compile rust for our micro-controller, we need to let it know what target to compile for. Microcontrollers like the STM32 use the thumb instruction set, which is a subset of the ARM instruction set. Rust has a target for the thumb instruction set, so we need to install it.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;rustup target add thumbv7em-none-eabihf
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Next, we need to create a new empty project using cargo.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;cargo new --bin blinky
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Cargo needs some more information to build for a microcontroller. So we need a &lt;code&gt;.cargo/config.toml&lt;/code&gt; file in the project directory with the following contents:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-toml&#34;&gt;[target.&#39;cfg(all(target_arch = &amp;quot;arm&amp;quot;, target_os = &amp;quot;none&amp;quot;))&#39;]
# replace  STM32F407VG with your chip as listed in `probe-rs chip list`
runner = &amp;quot;probe-rs run --chip STM32F407VG&amp;quot;

[target.thumbv7em-none-eabihf]
rustflags = [&amp;quot;-C&amp;quot;, &amp;quot;link-arg=-Tlink.x&amp;quot;]

[build]
target = &amp;quot;thumbv7em-none-eabihf&amp;quot;

[env]
DEFMT_LOG = &amp;quot;trace&amp;quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Also useful are some tools that can be used to prepare the binary for flashing onto the microcontroller. We can install these tools using cargo.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;cargo install cargo-binutils
rustup component add llvm-tools-preview
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;libraries&#34;&gt;Libraries&lt;/h2&gt;
&lt;p&gt;Rust has a lot of libraries already that support the hardware of the STM32, which makes things very convenient for us. Rust also has an excellent library called 
&lt;a href=&#34;https://embassy.dev&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;embassy&lt;/a&gt; - a lightweight async/await runtime that is designed to work on embedded devices. It is built on top of the &lt;code&gt;cortex-m&lt;/code&gt; crate, which provides low-level access to the ARM Cortex-M processors. In traditional C++ based embedded development, you would use an embedded RTOS like FreeRTOS or MBED OS to manage tasks and interrupts. However, with embasst, you can use the async/await syntax to write concurrent code that is (in my opinion) much easier to reason about and debug.&lt;/p&gt;
&lt;p&gt;To use embassy, add the following dependencies to your &lt;code&gt;Cargo.toml&lt;/code&gt; file:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-toml&#34;&gt;[package]
name = &amp;quot;stm32f407_tests&amp;quot;
authors = [&amp;quot;Ashwin Narayan &amp;lt; ashwinnarayan1994@gmail.com &amp;gt;&amp;quot;]
version = &amp;quot;0.1.0&amp;quot;
edition = &amp;quot;2021&amp;quot;

[[bin]]
name = &amp;quot;blinky&amp;quot;
path = &amp;quot;src/bin/blinky.rs&amp;quot;
test = false
bench = false

# Set up the release profile to optimize our binaries
[profile.release]
codegen-units = 1 # better optimizations
debug = true      # symbols are nice and they don&#39;t increase the size on Flash
lto = true        # better optimizations
opt-level = &amp;quot;s&amp;quot;   # Optimize for size

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
embassy-stm32 = { version = &amp;quot;0.1.0&amp;quot;, features = [
    &amp;quot;stm32f407vg&amp;quot;,
    &amp;quot;unstable-pac&amp;quot;,
    &amp;quot;memory-x&amp;quot;,
    &amp;quot;time-driver-any&amp;quot;,
    &amp;quot;exti&amp;quot;,
    &amp;quot;chrono&amp;quot;,
] }
embassy-executor = { version = &amp;quot;0.5.0&amp;quot;, features = [
    &amp;quot;integrated-timers&amp;quot;,
    &amp;quot;arch-cortex-m&amp;quot;,
    &amp;quot;executor-thread&amp;quot;,
] }
embassy-time = { version = &amp;quot;0.3.0&amp;quot; }
embassy-sync = { version = &amp;quot;0.5.0&amp;quot; }
cortex-m = { version = &amp;quot;0.7&amp;quot;, features = [&amp;quot;critical-section-single-core&amp;quot;] }
cortex-m-rt = &amp;quot;0.7&amp;quot;
panic-probe = { version = &amp;quot;0.3&amp;quot; }
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;We will then delete the &lt;code&gt;src/main.rs&lt;/code&gt; file and create a new file &lt;code&gt;src/bin/blinky.rs&lt;/code&gt; that will contain our code to blink our LEDs.&lt;/p&gt;
&lt;h2 id=&#34;blinking-an-led&#34;&gt;Blinking an LED&lt;/h2&gt;
&lt;p&gt;First, the code:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-rust&#34;&gt;#![no_std]
#![no_main]

use embassy_executor::Spawner;
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_time::{Duration, Ticker};
use panic_probe as _;

fn clock_config() -&amp;gt; embassy_stm32::Config {
    let mut config = embassy_stm32::Config::default();

    // Configure to use the high speed internal oscillator (HSI).
    config.rcc.hsi = true;

    config
}

#[embassy_executor::main]
async fn main(_spawner: Spawner) {
    // Initialize embassy
    let peripherals = embassy_stm32::init(clock_config());

    // Create a new output pin - PA9 is the green led on the Discovery board
    let mut green_led = Output::new(peripherals.PA9, Level::High, Speed::VeryHigh);
    let mut red_led = Output::new(peripherals.PD5, Level::High, Speed::VeryHigh);
    let mut green_led2 = Output::new(peripherals.PD12, Level::High, Speed::VeryHigh);
    let mut orange_led = Output::new(peripherals.PD13, Level::High, Speed::VeryHigh);
    let mut red_led2 = Output::new(peripherals.PD14, Level::High, Speed::VeryHigh);
    let mut blue_led = Output::new(peripherals.PD15, Level::High, Speed::VeryHigh);

    // Create a new Ticker for the delay
    let mut ticker = Ticker::every(Duration::from_millis(100));

    loop {
        // Wait for the ticker to expire
        ticker.next().await;

        // Toggle the leds
        green_led.toggle();
        red_led.toggle();
        green_led2.toggle();
        orange_led.toggle();
        red_led2.toggle();
        blue_led.toggle();
    }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Now let&amp;rsquo;s go through the code step by step and understand what each part does.&lt;/p&gt;
&lt;h3 id=&#34;no-standard-library-and-no-main&#34;&gt;No Standard Library and No Main&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&#34;language-rust&#34;&gt;#![no_std]
#![no_main]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;#![no_std]&lt;/code&gt; tells the rust compiler that we are building a binary without the standard library and &lt;code&gt;#![no_main]&lt;/code&gt; tells the Rust compiler that this program does not use the conventional main function as its entry point. This is typical in embedded applications where the entry point needs to conform to specific requirements or where the startup is handled by the hardware or a framework.&lt;/p&gt;
&lt;h3 id=&#34;importing-libraries&#34;&gt;Importing Libraries&lt;/h3&gt;
&lt;p&gt;Next, the library imports.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Spawner from embassy_executor is used to handle task spawning in an async environment.&lt;/li&gt;
&lt;li&gt;From embassy_stm32::gpio, we import Level, Output, and Speed to configure GPIO pins.&lt;/li&gt;
&lt;li&gt;Duration and Ticker from embassy_time are used to handle time-related functions like delays.&lt;/li&gt;
&lt;li&gt;panic_probe is a library used for better panic messages in embedded systems; the as _ means it&amp;rsquo;s used for its side effects (setting up panic handling) and not for its symbols.&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code class=&#34;language-rust&#34;&gt;use embassy_executor::Spawner;
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_time::{Duration, Ticker};
use panic_probe as _;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&#34;clock-configuration&#34;&gt;Clock Configuration&lt;/h3&gt;
&lt;p&gt;This function sets up the clock configuration for the STM32 microcontroller. It enables the High-Speed Internal oscillator (HSI) which is one of the clock sources that can drive the system clock.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-rust&#34;&gt;fn clock_config() -&amp;gt; embassy_stm32::Config {
    let mut config = embassy_stm32::Config::default();
    config.rcc.hsi = true; // Configure to use the high speed internal oscillator (HSI).
    config
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&#34;main-function&#34;&gt;Main Function&lt;/h3&gt;
&lt;p&gt;The &lt;code&gt;#[embassy_executor::main]&lt;/code&gt; attribute macro marks this asynchronous function as the entry point of the program. The function takes a Spawner argument for potentially spawning new asynchronous tasks. It initializes the STM32 peripherals according to our configuration.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-rust&#34;&gt;#[embassy_executor::main]
async fn main(_spawner: Spawner) {
    let peripherals = embassy_stm32::init(clock_config());
&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&#34;gpio-pins&#34;&gt;GPIO Pins&lt;/h3&gt;
&lt;p&gt;Next, we set up our GPIO pins according to the discovery board&amp;rsquo;s pinout. We create Output instances for each LED pin, specifying the pin number, initial level, and speed. The pins are configured as outputs, and the initial level is set to High. The speed is set to VeryHigh, which is the fastest speed available. The speed specifies the maximum frequency at which the pin can be toggled.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-rust&#34;&gt;let mut green_led = Output::new(peripherals.PA9, Level::High, Speed::VeryHigh);
...
let mut blue_led = Output::new(peripherals.PD15, Level::High, Speed::VeryHigh);
&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&#34;ticker-for-delays&#34;&gt;Ticker for Delays&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&#34;language-rust&#34;&gt;let mut ticker = Ticker::every(Duration::from_millis(100));
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Ticker is an &lt;code&gt;embassy_time&lt;/code&gt; construct. The &lt;code&gt;embassy_time&lt;/code&gt; crate provides time-related functionality for embedded systems. The &lt;code&gt;Ticker::every(Duration::from_millis(100))&lt;/code&gt; creates a new Ticker that expires every 100 milliseconds.&lt;/p&gt;
&lt;h3 id=&#34;the-main-loop&#34;&gt;The Main Loop&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&#34;language-rust&#34;&gt;loop {
    ticker.next().await;
    green_led.toggle();
    ...
    blue_led.toggle();
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The main loop waits for the ticker to expire, toggles the LEDs, and repeats the process indefinitely. The &lt;code&gt;ticker.next().await&lt;/code&gt; suspends the task until the ticker expires, allowing the LEDs to blink at regular intervals. The &lt;code&gt;toggle()&lt;/code&gt; method changes the state of the LED from on to off and vice versa.&lt;/p&gt;
&lt;h2 id=&#34;the-result&#34;&gt;The Result&lt;/h2&gt;
&lt;p&gt;&lt;img src=&#34;blinky.gif&#34; alt=&#34;Blinking LEDs&#34;&gt;&lt;/p&gt;
&lt;p&gt;If you want to take a look at the code, the full repository is available at my 
&lt;a href=&#34;https://github.com/RationalAsh/stm32f407-tests-rs&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;github&lt;/a&gt;.&lt;/p&gt;
&lt;h2 id=&#34;references&#34;&gt;References&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.rust-lang.org/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Rust Programming Language&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://rust-embedded.github.io/book/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Rust Embedded&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://embassy.dev&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Embassy&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://rustup.rs&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Rustup&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.st.com/en/evaluation-tools/stm32f4discovery.html&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;STM32F407 Discovery&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.st.com/resource/en/user_manual/um1472-discovery-kit-with-stm32f407vg-mcu-stmicroelectronics.pdf&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;STM32F407VG User Manual&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;
</description>
    </item>
    
    <item>
      <title>Reusable Forms in Swiftui</title>
      <link>https://www.ashwinnarayan.com/post/reusable-forms-swiftui/</link>
      <pubDate>Sun, 19 Mar 2023 13:52:25 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/reusable-forms-swiftui/</guid>
      <description>&lt;p&gt;I’ve been recently doing a lot of programming using Swift and I’m quite enjoying how intuitive it is to pick up. It also helps that SwiftUI generally produces good looking user interfaces with less effort than other things I’ve tried.&lt;/p&gt;
&lt;p&gt;Forms play a crucial role in creating interactive user interfaces for collecting and managing user input. Developing reusable form components in SwiftUI not only streamlines the development process but also ensures a consistent user experience throughout the app. By creating modular, reusable form components, developers can reduce code duplication, enhance maintainability, and simplify the process of updating or extending the functionality of their applications. In this article, we&amp;rsquo;ll explore the process of building a reusable login form component using SwiftUI.&lt;/p&gt;
&lt;p&gt;At the end of the article you should have a login form that looks like this:&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;screenshot.png&#34; alt=&#34;screenshot-login&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;first-the-code&#34;&gt;First, the code&lt;/h2&gt;
&lt;pre&gt;&lt;code class=&#34;language-swift&#34;&gt;import SwiftUI

struct LoginForm: View {
    @State private var username: String = &amp;quot;&amp;quot;
    @State private var password: String = &amp;quot;&amp;quot;
    let onLoginButtonPress: ((String, String) -&amp;gt; Void)?
    let onResetPasswordPress: (() -&amp;gt; Void)?
    
    var body: some View {
        VStack {
            Text(&amp;quot;Login to App&amp;quot;)
                .font(.title.bold())
                .padding()
            Spacer()
            TextField(&amp;quot;Username&amp;quot;, text: $username)
                .padding()
                .autocapitalization(.none)
                .disableAutocorrection(true)
                .border(Color.gray, width: 1)
            
            SecureField(&amp;quot;Password&amp;quot;, text: $password)
                .padding()
                .border(Color.gray, width: 1)
            
            Button(action: {
                onLoginButtonPress?(username, password)
            }) {
                Text(&amp;quot;Login&amp;quot;)
                    .padding()
                    .background(Color.blue)
                    .foregroundColor(.white)
                    .cornerRadius(5)
            }
            .padding()
            
            Spacer()
            
            Button {
                onResetPasswordPress?()
            } label: {
                Text(&amp;quot;Forgot your password? Click here to reset it.&amp;quot;)
                    .font(.caption)
                    .padding()
            }
        }
        .padding()
    }
}

struct LoginForm_Previews: PreviewProvider {
    static var previews: some View {
        LoginForm(onLoginButtonPress: { userName, password in
            print(&amp;quot;Login button tapped&amp;quot;)
            print(&amp;quot;Username is \(userName), password is \(password)&amp;quot;)
        },
        onResetPasswordPress: {
            print(&amp;quot;Reset password requested.&amp;quot;)
        })
    }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The code block above shows a login form where you can enter your username and password and has a button to login and a button to reset your password. Let’s take a look at how it works.&lt;/p&gt;
&lt;h2 id=&#34;storing-username-and-password-states&#34;&gt;Storing Username and Password States&lt;/h2&gt;
&lt;p&gt;We use private variables marked with &lt;code&gt;@State&lt;/code&gt; to hold the username and password variables. In SwiftUI, &lt;code&gt;@State&lt;/code&gt; is a property wrapper that manages the state of a value within a view. It provides local, mutable storage for simple values relevant to a specific view, allowing for mutability within an otherwise immutable view. &lt;code&gt;@State&lt;/code&gt; also allows child views or controls to read and write the property&amp;rsquo;s value using bindings, which is particularly useful for user input controls like TextField and Toggle. When a &lt;code&gt;@State&lt;/code&gt; property value changes, SwiftUI automatically re-renders the affected parts of the view hierarchy, ensuring that the view always reflects the current state of the data. It is important to use &lt;code&gt;@State&lt;/code&gt; only with value types, like structs, for proper change tracking, while other property wrappers like &lt;code&gt;@ObservedObject&lt;/code&gt; or &lt;code&gt;@EnvironmentObject&lt;/code&gt; are more suitable for reference types or complex data models.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-swift&#34;&gt;@State private var username: String = &amp;quot;&amp;quot;
@State private var password: String = &amp;quot;&amp;quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;To bind these properties to the &lt;code&gt;TextField&lt;/code&gt; and &lt;code&gt;SecureField&lt;/code&gt;, respectively, you&amp;rsquo;ll use the &lt;code&gt;$&lt;/code&gt; symbol in front of the property names to create a binding:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-swift&#34;&gt;TextField(&amp;quot;Username&amp;quot;, text: $username)
SecureField(&amp;quot;Password&amp;quot;, text: $password)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;By binding &lt;code&gt;@State&lt;/code&gt; variables to &lt;code&gt;TextField&lt;/code&gt; and &lt;code&gt;SecureField&lt;/code&gt;, you ensure that your view always reflects the current state of the data, and changes made by the user in the input controls are automatically captured and stored in the corresponding &lt;code&gt;@State&lt;/code&gt; properties.&lt;/p&gt;
&lt;h2 id=&#34;closures-for-form-actions&#34;&gt;Closures for Form Actions&lt;/h2&gt;
&lt;p&gt;In the LoginForm code, &lt;code&gt;onLoginButtonPress&lt;/code&gt; and &lt;code&gt;onResetPasswordPress&lt;/code&gt; are closure parameters that are passed to the LoginForm view. These closures define custom behavior that will be executed when the login button and reset password button are pressed, respectively.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;code&gt;onLoginButtonPress&lt;/code&gt;: This closure takes two input parameters, a String for the username and a String for the password. It gets called when the user taps the &amp;ldquo;Login&amp;rdquo; button. You can define custom login functionality within this closure, such as authentication and navigation to the next screen.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;onResetPasswordPress&lt;/code&gt;: This closure does not take any input parameters. It gets called when the user taps the &amp;ldquo;Forgot your password? Click here to reset it.&amp;rdquo; button. You can define custom reset password functionality within this closure, such as navigating to a password reset screen or showing a reset password prompt.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;By using these closure parameters, you can create a more flexible and reusable LoginForm component, as the specific functionality for handling login and password reset actions can be defined outside the LoginForm view, making it adaptable to various use cases within your app.&lt;/p&gt;
&lt;p&gt;You may also have noticed that I’ve made the closure parameters optional by marking them with a &lt;code&gt;?&lt;/code&gt; symbol. By marking them as optional, you indicate that these closures can have a value (a function) or be &lt;code&gt;nil&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;I prefer and recommend optional closures because it allows you to use the LoginForm component in cases where you might not need to provide both closures. For example, you might want to display a LoginForm that only requires a login action and not the reset password functionality, or vice versa. In such cases, you can simply pass &lt;code&gt;nil&lt;/code&gt; for the closure you don&amp;rsquo;t need, without having to modify the LoginForm component itself.&lt;/p&gt;
&lt;p&gt;You might have scenarios where the behavior of the LoginForm component changes based on certain conditions. By making the closures optional, you can decide at runtime whether or not to provide a specific closure based on the current context or app state.&lt;/p&gt;
&lt;p&gt;To safely call these optional closures, use the optional chaining syntax with the &lt;code&gt;?()&lt;/code&gt; operator:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-swift&#34;&gt;onLoginButtonPress?(username, password)
onResetPasswordPress?()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;This syntax ensures that the closure is only called if it has a non-nil value; otherwise, nothing happens, and the app continues to function without any issues.&lt;/p&gt;
&lt;h2 id=&#34;using-the-form-component-in-another-view&#34;&gt;Using the Form Component in Another View&lt;/h2&gt;
&lt;p&gt;Here’s how you’d use this form component in the main ContentView of your app as an example.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-swift&#34;&gt;import SwiftUI

struct ContentView: View {
    var body: some View {
        NavigationView {
            LoginForm(onLoginButtonPress: { username, password in
                // Implement your custom login functionality here
                print(&amp;quot;Login button tapped&amp;quot;)
                print(&amp;quot;Username: \(username), Password: \(password)&amp;quot;)
                
                // For example, you might perform authentication and navigate to the next screen
                
            }, onResetPasswordPress: {
                // Implement your custom reset password functionality here
                print(&amp;quot;Reset password requested.&amp;quot;)
                
                // For example, you might navigate to a password reset screen or show a reset password prompt
                
            })
            .navigationBarTitle(&amp;quot;Your App&amp;quot;, displayMode: .large)
        }
    }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;For &lt;code&gt;onLoginButtonPress&lt;/code&gt;, we print the username and password when the login button is tapped. In a real-world scenario, you&amp;rsquo;d likely perform authentication here and navigate to the next screen upon successful login.&lt;/p&gt;
&lt;p&gt;For &lt;code&gt;onResetPasswordPress&lt;/code&gt;, we print a message indicating that a password reset has been requested. In practice, you might navigate to a password reset screen, show a password reset prompt, or perform any other relevant action.&lt;/p&gt;
&lt;h2 id=&#34;summary&#34;&gt;Summary&lt;/h2&gt;
&lt;p&gt;In this article, we explored the creation of a reusable LoginForm component using SwiftUI. We learned about using &lt;code&gt;@State&lt;/code&gt; for local, mutable storage and two-way data binding with user interface controls, such as &lt;code&gt;TextField&lt;/code&gt; and &lt;code&gt;SecureField&lt;/code&gt;. We also discussed the flexibility and adaptability of the LoginForm component through optional closure parameters for handling login and password reset actions. SwiftUI&amp;rsquo;s declarative approach and powerful features, such as property wrappers and bindings, make it easy and efficient to build modular and reusable components for user interfaces. As you continue to delve into SwiftUI, you&amp;rsquo;ll find that it greatly simplifies app development and promotes consistent user experiences across your applications. Keep exploring and expanding your SwiftUI knowledge, and you&amp;rsquo;ll be well-equipped to create fantastic apps that delight your users.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Blockchain</title>
      <link>https://www.ashwinnarayan.com/project/blockchain/</link>
      <pubDate>Thu, 04 Aug 2022 11:36:56 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/project/blockchain/</guid>
      <description>&lt;p&gt;I recently got into blockchain development focused on the Solana blockchain. I&amp;rsquo;ve been learning to build both Rust smart contracts and React based frontends. To see what I&amp;rsquo;m working on, subscribe to me at 
&lt;a href=&#34;https://solanadevjournal.substack.com&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Solana Dev Journal&lt;/a&gt;.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.ashwinnarayan.com/dapps/solana-faucet/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Solana Airdropper&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://useless-nft-generator.space&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;NFT Minter&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.ashwinnarayan.com/dapps/kudos-program/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Kudos Program&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;
</description>
    </item>
    
    <item>
      <title>Blockchains as I Understand It</title>
      <link>https://www.ashwinnarayan.com/post/blockchains-as-i-understand-it/</link>
      <pubDate>Tue, 02 Aug 2022 17:15:34 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/blockchains-as-i-understand-it/</guid>
      <description>&lt;h2 id=&#34;introduction&#34;&gt;Introduction&lt;/h2&gt;
&lt;p&gt;The first half of 2022 has not been kind to the world of crypto. Everyone expects a recession, cryptocurrency valuations are crashing; crypto firms file for bankruptcy every other week and many are predecting a &amp;ldquo;crypto winter&amp;rdquo;. As bad as things may seem, many would argue that the hype driven valuations crypto-currencies and associated projects were unsustainable, and had to come down eventually. Regardless, now that a lot of the hype and noise have faded, I feel that it is a good time to dive into the technical aspects of crypto currency technology with an academic mindset and learn about how it works.&lt;/p&gt;
&lt;h3 id=&#34;blockchains-and-smart-contracts&#34;&gt;Blockchains and Smart Contracts&lt;/h3&gt;
&lt;p&gt;The mathematics behind cryptocurrencies and blockchains have fascinated me since since 2012 - when I first heard about Bitcoin. Bitcoin pioneered the idea of a decentralized ledger of transactions of virtual tokens. However, modern blockchains have come a long way since then. In addition transactions of virtual tokens, blockchain today allow execution of arbitray logic on the blockchain - i.e., smart contracts. The mathematics of cryptography is what makes these features of blockchains possible.&lt;/p&gt;
&lt;h4 id=&#34;cyrptographic-hash-functions&#34;&gt;Cyrptographic Hash Functions&lt;/h4&gt;
&lt;p&gt;Cryptographic hash functions (CHFs) are mathematical functions take data as input and produce a &amp;ldquo;fingerprint&amp;rdquo; that is pre-image resistant - i.e. it is difficult to know what you put into the function given the output of the function.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;hash-functions.png&#34; alt=&#34;hash_functions&#34;&gt;&lt;/p&gt;
&lt;p&gt;CHFs also have a few other properties. It&amp;rsquo;s difficult to find two inputs that have the same hash value and small changes to the file results in large changes to the hash.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-sh&#34;&gt;~ % echo &amp;quot;Hello&amp;quot; | md5sum
09f7e02f1290be211da707a266f153b3  -

~ % echo &amp;quot;Hellp&amp;quot; | md5sum
a907206b6e6bf63124d4fa1e499eac8c  -
&lt;/code&gt;&lt;/pre&gt;
&lt;h4 id=&#34;public-key-cryptography&#34;&gt;Public Key Cryptography&lt;/h4&gt;
&lt;p&gt;Public key cryptography lies at the foundation of how many blockchains work. These cryptographic systems uses two sets of numbers or &amp;ldquo;keys&amp;rdquo; for each person who wants to communicate. One key is kept a secret while the other is visible to everyone. If I want to send an encrypted message to Albert Einstein, I use a mathematical function that takes Einstein&amp;rsquo;s public key and the message as input and produces an encrypted message. The encrypted message will look like random noise to anyone except Einstein (well his computer at least) who can use his secret key with a mathematical decryption function to decrypt the message.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;public-key-cryptography.png&#34; alt=&#34;public_key_cryptography&#34;&gt;&lt;/p&gt;
&lt;h4 id=&#34;digital-signatures&#34;&gt;Digital Signatures&lt;/h4&gt;
&lt;p&gt;Public / Private keypairs can also be used to produce what are called digital signatures that prove that the person who owns the private key has written (or at least has signed) a message. Digital signature schemes first generate a hash of a document using a cryptographic hash function and then encrypt the hash using your private key. Anyone else can then verify that it is indeed signed using your private key by decrypting the signature using your private key and comparing it to the hash of the document.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;digital-signatures.png&#34; alt=&#34;digital_signatures&#34;&gt;&lt;/p&gt;
&lt;h4 id=&#34;how-bitcoin-works-briefly&#34;&gt;How Bitcoin Works, Briefly&lt;/h4&gt;
&lt;p&gt;Each transaction on the Bitcoin network is written in a small 
&lt;a href=&#34;https://en.bitcoin.it/wiki/Script&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;scripting language&lt;/a&gt;. Bitcoin wallets - which are essentially a secret / public keypair - sign and send transactions to computers on the internet that are running code to verify blocks of tranasactions. These computers batch together transactions into blocks and try to find a number to add to a block of transactions (called a &lt;em&gt;nonce&lt;/em&gt;) so that the cryptographic hash (SHA-256) of the block and the nonce has a specific number of leading zeroes. Finding the nonce is difficult to do because the brute-force method of searching through all possible combinations is the best way we know.&lt;/p&gt;
&lt;p&gt;However, because of how cryptographic hashes work, it is easy to verify that the hash of the block with the nonce has the required number of leading zeroes. Therefore, the hash is &lt;strong&gt;proof&lt;/strong&gt; that someone has done the &lt;strong&gt;work&lt;/strong&gt; to verify the transaction. In the Bitcoin network, each block also contains the hash of the previous block so that we know the order in which the blocks were verified. The official ledger of transactions is the longest &lt;strong&gt;chain&lt;/strong&gt; of &lt;strong&gt;blocks&lt;/strong&gt; that have been verified by computers (miners) this way. In return for verifying transactions, the wallet that first verifies a block is rewarded with the fees of all the block&amp;rsquo;s transactions and a small amount of newly minted Bitcoin.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;bitcoin-visualized.png&#34; alt=&#34;bitcoin_blockchain&#34;&gt;&lt;/p&gt;
&lt;h4 id=&#34;how-smart-contracts-work-briefly&#34;&gt;How Smart Contracts Work, Briefly&lt;/h4&gt;
&lt;p&gt;Smart contracts are an extension of the blockchain to transactions other than sending tokens between accounts. Bitcoin&amp;rsquo;s scripting language is intentionally limited (i.e. it is not Turing Complete). Blockchains like Ethereum implement a Turing complete scripting language that allows the contract to store state and perform arbitrary calculations. This lets you make more complicated things on the blockchain. So a smart contract is essentially code which instead of executing on your computer is executed on other computers along with some cryptographic calculations to verify what the code did. This computation costs money (miners or validators need to pay for electricity) and gas fees are the reward that validators on the blockchain get for executing the smart contract logic.&lt;/p&gt;
&lt;h2 id=&#34;summary&#34;&gt;Summary&lt;/h2&gt;
&lt;p&gt;Blockchains essentially solve the problem of carrying out calculations and maintainings ledgers in a decentralized, trustless way. Rather than trusting a central authority (like a bank) to honestly keep track of your money, blockchains rely on mathematical rules which &lt;strong&gt;when correctly followed&lt;/strong&gt; ensure that the probability of the ledger of transactions being honest is very high. However, the cost of a trustless system if a lack of recourse if you do not follow the rules. For instance, if your 
&lt;a href=&#34;https://www.coindesk.com/markets/2022/08/03/phantom-wallet-exploit-drains-millions-in-sol-tokens/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;private keys are leaked&lt;/a&gt; you cannot retrieve your tokens from the thief because there is no &amp;ldquo;central authority&amp;rdquo; who can restore your wallet.&lt;/p&gt;
&lt;h2 id=&#34;references&#34;&gt;References&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.cbsnews.com/news/celsius-bankruptcy-filing-most-activity-still-paused/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;https://www.cbsnews.com/news/celsius-bankruptcy-filing-most-activity-still-paused/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://fortune.com/2022/07/08/voyager-crypto-bankruptcy-protection-next-steps-life-savings/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;https://fortune.com/2022/07/08/voyager-crypto-bankruptcy-protection-next-steps-life-savings/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.forbes.com/sites/jonathanponciano/2022/07/14/crypto-winter-watch-all-the-big-layoffs-record-withdrawals-and-bankruptcies-sparked-by-the-2-trillion-crash/?sh=4eb8957020f5&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;https://www.forbes.com/sites/jonathanponciano/2022/07/14/crypto-winter-watch-all-the-big-layoffs-record-withdrawals-and-bankruptcies-sparked-by-the-2-trillion-crash/?sh=4eb8957020f5&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.youtube.com/watch?v=bBC-nXj3Ng4&amp;amp;t=906s&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;https://www.youtube.com/watch?v=bBC-nXj3Ng4&amp;amp;t=906s&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://en.bitcoin.it/wiki/Script&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Bitcoin Scripting Language&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.youtube.com/watch?v=GU4igNeYr-Q&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;https://www.youtube.com/watch?v=GU4igNeYr-Q&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://en.wikipedia.org/wiki/Cryptographic_hash_function&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;https://en.wikipedia.org/wiki/Cryptographic_hash_function&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.docusign.com/how-it-works/electronic-signature/digital-signature/digital-signature-faq&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;https://www.docusign.com/how-it-works/electronic-signature/digital-signature/digital-signature-faq&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;
</description>
    </item>
    
    <item>
      <title>A Morning Walk Along The Rail Corridor</title>
      <link>https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/</link>
      <pubDate>Fri, 22 Apr 2022 10:14:53 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/</guid>
      <description>&lt;p&gt;I&amp;rsquo;ve been doing early morning photo walks lately to replace my &amp;ldquo;wake up and scroll the phone&amp;rdquo; habit. In addition to getting a bit of exercise in I also get to see nice scenery and take photos! I live near one of the entrances to Singapore&amp;rsquo;s Rail Corridor. Today morning, I decided to walk along a section of it and take as many photos as I can.&lt;/p&gt;
&lt;p&gt;I intended to wake up at 6.00 a.m., but it was 6.20 by the time I managed to shake off all my sleepiness. I was a little apprehensive about the weather as this week has been unusually rainy and cloudy. However, the sky was already light orange when I set out. Thin, wispy clouds stretched out across the eastern horizon. I took the shortest route to the main road from where I could see the sky. Majestic shafts of light were already shining through breaks in the cloud cover.&lt;/p&gt;





  
  











&lt;figure id=&#34;figure-shafts-of-light&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/sky1_hu6525cb3507b48870ae99821a7840af61_14333711_2000x2000_fit_q90_lanczos.jpeg&#34; data-caption=&#34;Shafts of light&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/sky1_hu6525cb3507b48870ae99821a7840af61_14333711_2000x2000_fit_q90_lanczos.jpeg&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;5033&#34; height=&#34;4000&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    Shafts of light
  &lt;/figcaption&gt;


&lt;/figure&gt;

&lt;p&gt;I like this time in the morning when the sky is beginning to get lighter, but the streetlamps haven&amp;rsquo;t turned off yet. It feels like the lamps are clinging on to that last bit of night, hoping that it will last just a little longer.&lt;/p&gt;





  
  











&lt;figure id=&#34;figure-the-lamps-were-still-shining-and-the-wispy-clouds-were-casting-shadows-in-the-sky&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/lonely-lamp_hu849b0110fe347dadf8ecdfbc628fd5a9_4299705_2000x2000_fit_q90_lanczos.JPG&#34; data-caption=&#34;The lamps were still shining, and the wispy clouds were casting shadows in the sky.&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/lonely-lamp_hu849b0110fe347dadf8ecdfbc628fd5a9_4299705_2000x2000_fit_q90_lanczos.JPG&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;5328&#34; height=&#34;4000&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    The lamps were still shining, and the wispy clouds were casting shadows in the sky.
  &lt;/figcaption&gt;


&lt;/figure&gt;

&lt;p&gt;Dawn time skies have always embodied a sense of evanescence to me. The light and shadows changed every time I looked up. The shafts of light soon faded, and the sky brightened. I could see more of the golden morning light in the sky.&lt;/p&gt;





  
  











&lt;figure id=&#34;figure-the-lamps-were-still-shining-and-the-wispy-clouds-were-casting-shadows-in-the-sky&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/three-trees_huf8814ff9b9758148daf2f732faf2d859_186853_2000x2000_fit_q90_lanczos.jpeg&#34; data-caption=&#34;The lamps were still shining, and the wispy clouds were casting shadows in the sky.&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/three-trees_huf8814ff9b9758148daf2f732faf2d859_186853_2000x2000_fit_q90_lanczos.jpeg&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;1249&#34; height=&#34;960&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    The lamps were still shining, and the wispy clouds were casting shadows in the sky.
  &lt;/figcaption&gt;


&lt;/figure&gt;






  
  











&lt;figure id=&#34;figure-the-clock-tower&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/featured_hu0658c00cd3310781b57c94ad1b0cb3fc_4929206_2000x2000_fit_q90_lanczos.JPG&#34; data-caption=&#34;The clock tower.&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/featured_hu0658c00cd3310781b57c94ad1b0cb3fc_4929206_2000x2000_fit_q90_lanczos.JPG&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;5328&#34; height=&#34;4000&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    The clock tower.
  &lt;/figcaption&gt;


&lt;/figure&gt;

&lt;p&gt;The air was cool but humid, and my glasses were covered in a permanent fog from mask-breath. Ferns, tall grasses, and overgrown vines lined the entrance to the rail corridor. Tall trees occasionally rose above the greenery. Skyscrapers and residential buildings towered above the trees on either side of the walkway. Some of the taller buildings were already beginning to catch a bit of sunlight. The waning gibbous moon was visible high in the sky, unobstructed by clouds. Despite its notoriety as a difficult subject to capture, my camera proved capable enough to capture some surface detail.&lt;/p&gt;





  
  











&lt;figure id=&#34;figure-the-moon-was-still-bright-in-the-sky&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/moon-1_hu67988bae97c0f4b74bcdcfe5210bca90_6505320_2000x2000_fit_q90_lanczos.JPG&#34; data-caption=&#34;The moon was still bright in the sky.&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/moon-1_hu67988bae97c0f4b74bcdcfe5210bca90_6505320_2000x2000_fit_q90_lanczos.JPG&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;5328&#34; height=&#34;4000&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    The moon was still bright in the sky.
  &lt;/figcaption&gt;


&lt;/figure&gt;






  
  











&lt;figure id=&#34;figure-some-of-the-surface-detail-on-the-moon-is-visible-here&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/moon-2_hu7b1f9085b3dde423558c22d7954989c3_3855523_2000x2000_fit_q90_lanczos.JPG&#34; data-caption=&#34;Some of the surface detail on the moon is visible here.&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/moon-2_hu7b1f9085b3dde423558c22d7954989c3_3855523_2000x2000_fit_q90_lanczos.JPG&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;5328&#34; height=&#34;4000&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    Some of the surface detail on the moon is visible here.
  &lt;/figcaption&gt;


&lt;/figure&gt;

&lt;p&gt;A short walk brought me to a futuristic looking bridge that connected either side of the rail corridor. I noticed that the lamps were finally off. The morning was officially here.&lt;/p&gt;





  
  











&lt;figure id=&#34;figure-lamps-are-finally-off-the-morning-is-here&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/lamps-off_hu7b1f9085b3dde423558c22d7954989c3_3770097_2000x2000_fit_q90_lanczos.JPG&#34; data-caption=&#34;Lamps are finally off. The morning is here.&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/lamps-off_hu7b1f9085b3dde423558c22d7954989c3_3770097_2000x2000_fit_q90_lanczos.JPG&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;5328&#34; height=&#34;4000&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    Lamps are finally off. The morning is here.
  &lt;/figcaption&gt;


&lt;/figure&gt;

&lt;p&gt;The sun rose behind a building on the horizon. The sky was starting to get really bright, and its light was glinting off the glass windows on many nearby buildings.&lt;/p&gt;





  
  











&lt;figure id=&#34;figure-the-sun-finally-shows-itself&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/sunrise-1_hu7b1f9085b3dde423558c22d7954989c3_3535398_2000x2000_fit_q90_lanczos.JPG&#34; data-caption=&#34;The sun finally shows itself.&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/sunrise-1_hu7b1f9085b3dde423558c22d7954989c3_3535398_2000x2000_fit_q90_lanczos.JPG&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;5328&#34; height=&#34;4000&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    The sun finally shows itself.
  &lt;/figcaption&gt;


&lt;/figure&gt;






  
  











&lt;figure id=&#34;figure-this-plant-looked-really-cool-against-the-sunrise&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/sunrise-2_hu7b1f9085b3dde423558c22d7954989c3_3830527_2000x2000_fit_q90_lanczos.JPG&#34; data-caption=&#34;This plant looked really cool against the sunrise.&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/sunrise-2_hu7b1f9085b3dde423558c22d7954989c3_3830527_2000x2000_fit_q90_lanczos.JPG&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;5328&#34; height=&#34;4000&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    This plant looked really cool against the sunrise.
  &lt;/figcaption&gt;


&lt;/figure&gt;

&lt;p&gt;Singapore is generally hot, but mornings are occasionally cold enough for dew drops to form. Today was one of those mornings.&lt;/p&gt;





  
  











&lt;figure id=&#34;figure-many-of-the-plants-lining-the-road-had-dew-drops-clinking-to-the-leaves&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/dew-leaves_hu7b1f9085b3dde423558c22d7954989c3_5980544_2000x2000_fit_q90_lanczos.JPG&#34; data-caption=&#34;Many of the plants lining the road had dew drops clinking to the leaves.&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/dew-leaves_hu7b1f9085b3dde423558c22d7954989c3_5980544_2000x2000_fit_q90_lanczos.JPG&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;5328&#34; height=&#34;4000&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    Many of the plants lining the road had dew drops clinking to the leaves.
  &lt;/figcaption&gt;


&lt;/figure&gt;

&lt;p&gt;By the time I reached the first exit on this section of the rail corridor, the sun had fully risen. That was my cue to get breakfast.&lt;/p&gt;





  
  











&lt;figure id=&#34;figure-bright-blue-sky&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/bright-blue-sky_hu332040434051a36e47d6c9464a460355_5178156_2000x2000_fit_q90_lanczos.JPG&#34; data-caption=&#34;Bright blue sky.&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/post/a-morning-walk-rail-corridor/bright-blue-sky_hu332040434051a36e47d6c9464a460355_5178156_2000x2000_fit_q90_lanczos.JPG&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;5328&#34; height=&#34;4000&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    Bright blue sky.
  &lt;/figcaption&gt;


&lt;/figure&gt;

</description>
    </item>
    
    <item>
      <title>Haskell Folds Illustrated</title>
      <link>https://www.ashwinnarayan.com/post/a-study-on-haskell-folds/</link>
      <pubDate>Sat, 01 Jan 2022 18:54:25 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/a-study-on-haskell-folds/</guid>
      <description>&lt;h2 id=&#34;introduction&#34;&gt;Introduction&lt;/h2&gt;
&lt;p&gt;Now that I&amp;rsquo;ve submitted my PhD thesis for examination (finally!) I can spend some time fiddling around with things that are unrelated to it. After a hiatus of several months I&amp;rsquo;m finally back to playing with Haskell.&lt;/p&gt;
&lt;p&gt;One of the things that make Haskell notoriously hard and non-intuitive to learn is the idea of functions that act on other functions (higher order functions). Folds were the first thing that really made things fit together in my mind and helped me understand the strengths of functional programming and why people rave about elegance in haskell.&lt;/p&gt;
&lt;p&gt;Haskell has two types of folds: the left fold and the right fold with slightly different function signatures. Folds take a function that takes two arguments and returns a third &lt;code&gt;(a -&amp;gt; b -&amp;gt; a)&lt;/code&gt;, a value that can be considered a &amp;ldquo;seed&amp;rdquo; value, and a list. For the right fold, the seed has to be of the same type as the second argument of the function and the list elements have to have the same type as the first argument of the function. For the left fold, this is reversed. The seed has to be of the same type as the first argument to the function and the list elements have to be of the same type as the first argument of the function.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-hs&#34;&gt;foldl :: (a -&amp;gt; b -&amp;gt; a) -&amp;gt; a -&amp;gt; [b] -&amp;gt; a
foldr :: (a -&amp;gt; b -&amp;gt; b) -&amp;gt; b -&amp;gt; [a] -&amp;gt; b
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Folds work like knocking down an arrangement of dominoes. It takes the seed value and the first element in the list and applies the function you have it. Then it repeatedly applies the function to the result and the next item in the list until all items in the list are consumed.&lt;/p&gt;
&lt;h2 id=&#34;the-left-fold---illustrated&#34;&gt;The Left Fold - Illustrated&lt;/h2&gt;
&lt;pre&gt;&lt;code class=&#34;language-mermaid&#34;&gt;graph TD
  BN[&amp;quot;B[N]&amp;quot;] --- FN
  FN[fun :: b -&amp;gt; a -&amp;gt; b] -.- |&amp;quot;B[N-1]&amp;quot;|F2
  FN --- AN[&amp;quot;A[N]&amp;quot;]
  F2[fun :: b -&amp;gt; a -&amp;gt; b] --- |&amp;quot;B[1]&amp;quot;|F1
  F2 --- A1[&amp;quot;A[1]&amp;quot;]
  F1 --- S[&amp;quot;B[0]&amp;quot;]
  F1[fun :: b -&amp;gt; a -&amp;gt; b] --- A0[&amp;quot;A[0]&amp;quot;]

&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;the-right-fold---illustrated&#34;&gt;The Right Fold - Illustrated&lt;/h2&gt;
&lt;pre&gt;&lt;code class=&#34;language-mermaid&#34;&gt;graph TD
  BN[&amp;quot;B[N]&amp;quot;] --- FN
  FN[fun :: b -&amp;gt; a -&amp;gt; b] -.- |&amp;quot;B[N-1]&amp;quot;|F2
  FN --- AN[&amp;quot;A[0]&amp;quot;]
  F2[fun :: b -&amp;gt; a -&amp;gt; b] --- |&amp;quot;B[1]&amp;quot;|F1
  F2 --- A1[&amp;quot;A[N-1]&amp;quot;]
  F1 --- S[&amp;quot;B[0]&amp;quot;]
  F1[fun :: b -&amp;gt; a -&amp;gt; b] --- A0[&amp;quot;A[N]&amp;quot;]

&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;applications&#34;&gt;Applications&lt;/h2&gt;
&lt;h3 id=&#34;summing-lists&#34;&gt;Summing lists&lt;/h3&gt;
&lt;p&gt;A standard illustrative example is how a fold can be used to sum a list.&lt;/p&gt;
&lt;p&gt;Following the diagram, &lt;code&gt;foldl (+) 0 [1, 2, 3, 4, 5]&lt;/code&gt; would evaluate as 15. The fold function applies the &lt;code&gt;(+)&lt;/code&gt; operator to 0 and the 1 (the first element). Then apply &lt;code&gt;(+)&lt;/code&gt; to the result and the second element in the list and so on until we get the final result.&lt;/p&gt;
&lt;h3 id=&#34;integration&#34;&gt;Integration&lt;/h3&gt;
&lt;p&gt;A neat extension to summing lists is numerical integration. The simplest integral of an signal $x[t]$ (represnted by a list of values) with a sampling time $\Delta T$ can be expressed very simply as a fold (combined with a map).&lt;/p&gt;
&lt;p&gt;The equation&lt;/p&gt;
&lt;p&gt;$$ S = \sum_{i=0}^{N} x[i] \cdot \Delta T $$&lt;/p&gt;
&lt;p&gt;Turns into&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-hs&#34;&gt;simpleIntegral :: Double -&amp;gt; [Double] -&amp;gt; Double
simpleIntegral dT fvals = foldl1 (+) (map (*dT) fvals)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Here, &lt;code&gt;foldl1&lt;/code&gt; is a version of fold that takes the first element of the list as the seed.&lt;/p&gt;
&lt;h3 id=&#34;scans-and-filtering&#34;&gt;Scans and Filtering&lt;/h3&gt;
&lt;p&gt;From the illustrations of the left and right folds you can see that the folds produce a set of intermediate results that get fed back into the function. When having the intermediate results are useful, we have &lt;code&gt;scan&lt;/code&gt;. &lt;code&gt;scan&lt;/code&gt; is a fold that returns the intermediate results as a list rather than just the final result. This is useful in a lot of filtering operations; for instance to calculate the exponential moving average of stock prices.&lt;/p&gt;
&lt;p&gt;$$\begin{equation*}
S_t=\begin{cases}
Y_1 \quad &amp;amp;\text{if} , t = 0 \\
\alpha Y_{t} + (1-\alpha) S_{t-1} &amp;amp;\text{if} , t \gt 0 \\
\end{cases}
\end{equation*}$$&lt;/p&gt;
&lt;p&gt;The EMA equation can be implemented as:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-hs&#34;&gt;ema :: Double -&amp;gt; [Double] -&amp;gt; [Double]
ema alpha vals = scanl1 (\prev curr -&amp;gt; alpha*curr + (1-alpha)*prev) vals
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;summing-up&#34;&gt;Summing Up&lt;/h2&gt;
&lt;p&gt;Interestingly, the Complementary Filter - often used to measure tilts using IMU sensors follow a very similar format and folds can be used to implement these type of filters. This is the biggest strength of using higher order functions. They capture commonly used patterns of calculations in a very general way. If you use a fold, the Haskell compiler will produce highly optimized code to run your calculation. If you were to use hand-written loops - especially in programming languages like C/C++ - you might write code that is inefficient or segfaults. Higher order functions are also very general. Haskell&amp;rsquo;s &lt;code&gt;foldl&lt;/code&gt; and &lt;code&gt;foldr&lt;/code&gt; works on any data type at all. This is the reason the type signatures for these functions don&amp;rsquo;t mention any concrete types. While I&amp;rsquo;ve only applied these functions to &lt;code&gt;Double&lt;/code&gt; data types, you can use this pattern on Strings, integers and on random custom defined data types. Higher order functions are also elegant. Rather than writing an ugly loop, I could write a one liner to do integration or complementary filtering. This is actually quite similar to how MATLAB scripting lets me express complicated operations like a matrix multiplication with a single operator.&lt;/p&gt;
&lt;h2 id=&#34;references&#34;&gt;References&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;a href=&#34;http://learnyouahaskell.com/higher-order-functions&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Learn You a Haskell&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.cs.nott.ac.uk/~pszgmh/fold.pdf&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Hutton, Graham. &amp;ldquo;A tutorial on the universality and expressiveness of fold.&amp;rdquo; &lt;em&gt;Journal of Functional Programming&lt;/em&gt; 9.4 (1999): 355-372.&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://en.wikipedia.org/wiki/Moving_average&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Exponential Moving Average&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;
</description>
    </item>
    
    <item>
      <title>Buona Vista</title>
      <link>https://www.ashwinnarayan.com/project/buona-vista-park-connector/</link>
      <pubDate>Fri, 02 Jul 2021 09:30:39 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/project/buona-vista-park-connector/</guid>
      <description>&lt;p&gt;All images were shot on analog film using an old Minolta X-700 camera. I&amp;rsquo;m putting up the photos here in a zoomable format because many of these photos are best viewed on a big screen. Hover over the image and click to open them in full screen. To see more of my photography, follow me on 
&lt;a href=&#34;https://www.instagram.com/ashwin_takes_photographs/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Instagram&lt;/a&gt;&lt;/p&gt;





  
  











&lt;figure id=&#34;figure-outside-the-tunnel-that-leads-from-the-mrt-station-the-rail-corridor&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/project/buona-vista-park-connector/featured_hu16d79b0c30697bc8581a378b5135efeb_2516905_2000x2000_fit_q90_lanczos.jpeg&#34; data-caption=&#34;Outside the tunnel that leads from the MRT station the Rail Corridor.&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/project/buona-vista-park-connector/featured_hu16d79b0c30697bc8581a378b5135efeb_2516905_2000x2000_fit_q90_lanczos.jpeg&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;2515&#34; height=&#34;2048&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    Outside the tunnel that leads from the MRT station the Rail Corridor.
  &lt;/figcaption&gt;


&lt;/figure&gt;






  
  











&lt;figure id=&#34;figure-the-green-space-near-ghim-moh-market&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/project/buona-vista-park-connector/green-space_hud407896f8e8177dbd1be5283d3cb7695_2116587_2000x2000_fit_q90_lanczos.jpeg&#34; data-caption=&#34;The green space near Ghim Moh Market.&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/project/buona-vista-park-connector/green-space_hud407896f8e8177dbd1be5283d3cb7695_2116587_2000x2000_fit_q90_lanczos.jpeg&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;3089&#34; height=&#34;2048&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    The green space near Ghim Moh Market.
  &lt;/figcaption&gt;


&lt;/figure&gt;






  
  











&lt;figure id=&#34;figure-view-of-the-mrt-station-from-crossing&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/project/buona-vista-park-connector/crossing_hu4ff0442ae264bd99580681c8118242bf_1885414_2000x2000_fit_q90_lanczos.jpeg&#34; data-caption=&#34;View of the MRT Station from Crossing.&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/project/buona-vista-park-connector/crossing_hu4ff0442ae264bd99580681c8118242bf_1885414_2000x2000_fit_q90_lanczos.jpeg&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;2048&#34; height=&#34;3089&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    View of the MRT Station from Crossing.
  &lt;/figcaption&gt;


&lt;/figure&gt;






  
  











&lt;figure id=&#34;figure-sunset-on-the-park-connector&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/project/buona-vista-park-connector/pcn-1_hu639196838a5f110a94fe1e3e61aec7b4_946877_2000x2000_fit_q90_lanczos.jpeg&#34; data-caption=&#34;Sunset on the Park Connector.&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/project/buona-vista-park-connector/pcn-1_hu639196838a5f110a94fe1e3e61aec7b4_946877_2000x2000_fit_q90_lanczos.jpeg&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;1439&#34; height=&#34;2142&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    Sunset on the Park Connector.
  &lt;/figcaption&gt;


&lt;/figure&gt;






  
  











&lt;figure id=&#34;figure-sunset-on-the-park-connector&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/project/buona-vista-park-connector/pcn-2_hu2c5f54a288d48319b4017eb458d98481_1520188_2000x2000_fit_q90_lanczos.jpeg&#34; data-caption=&#34;Sunset on the Park Connector.&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/project/buona-vista-park-connector/pcn-2_hu2c5f54a288d48319b4017eb458d98481_1520188_2000x2000_fit_q90_lanczos.jpeg&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;2048&#34; height=&#34;2839&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    Sunset on the Park Connector.
  &lt;/figcaption&gt;


&lt;/figure&gt;






  
  











&lt;figure id=&#34;figure-a-really-colorful-tree-on-the-park-connector&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/project/buona-vista-park-connector/colorful-tree_hu67956fb388c0aadd31bf51d0f8bbf5f1_1763647_2000x2000_fit_q90_lanczos.jpeg&#34; data-caption=&#34;A really colorful tree on the Park Connector.&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/project/buona-vista-park-connector/colorful-tree_hu67956fb388c0aadd31bf51d0f8bbf5f1_1763647_2000x2000_fit_q90_lanczos.jpeg&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;2048&#34; height=&#34;3089&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    A really colorful tree on the Park Connector.
  &lt;/figcaption&gt;


&lt;/figure&gt;

</description>
    </item>
    
    <item>
      <title>Ipoh Skyscapes</title>
      <link>https://www.ashwinnarayan.com/project/ipoh-skyscapes/</link>
      <pubDate>Wed, 26 May 2021 15:49:20 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/project/ipoh-skyscapes/</guid>
      <description>&lt;p&gt;For about five years, I lived in a city called Ipoh. My room at the time had access to some of the best sunsets I&amp;rsquo;ve ever seen in my life. I would capture what I could using a small digital camera that I had on hand. It&amp;rsquo;s probably the reason that skies and sunsets are my favorite subjects to photograph. For more photos, check out my 
&lt;a href=&#34;https://www.instagram.com/ashwin_takes_photographs/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Instagram&lt;/a&gt;.&lt;/p&gt;





  
  











&lt;figure id=&#34;figure-lens-flare&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/project/ipoh-skyscapes/image-gallery/ipoh-skyscape-1_huff4050c84021aa42d86de6ab7f382f2d_129422_2000x2000_fit_q90_lanczos.jpg&#34; data-caption=&#34;Lens Flare&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/project/ipoh-skyscapes/image-gallery/ipoh-skyscape-1_huff4050c84021aa42d86de6ab7f382f2d_129422_2000x2000_fit_q90_lanczos.jpg&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;1365&#34; height=&#34;2048&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    Lens Flare
  &lt;/figcaption&gt;


&lt;/figure&gt;






  
  











&lt;figure id=&#34;figure-window-at-dusk&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/project/ipoh-skyscapes/image-gallery/ipoh-skyscape-2_huff4050c84021aa42d86de6ab7f382f2d_121643_2000x2000_fit_q90_lanczos.jpg&#34; data-caption=&#34;Window at Dusk&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/project/ipoh-skyscapes/image-gallery/ipoh-skyscape-2_huff4050c84021aa42d86de6ab7f382f2d_121643_2000x2000_fit_q90_lanczos.jpg&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;1365&#34; height=&#34;2048&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    Window at Dusk
  &lt;/figcaption&gt;


&lt;/figure&gt;






  
  











&lt;figure id=&#34;figure-orange-sky&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/project/ipoh-skyscapes/image-gallery/Orange-clouds_hubb760f67d067bc916243ef34dd4e5e56_1497246_2000x2000_fit_q90_lanczos.jpeg&#34; data-caption=&#34;Orange Sky&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/project/ipoh-skyscapes/image-gallery/Orange-clouds_hubb760f67d067bc916243ef34dd4e5e56_1497246_2000x2000_fit_q90_lanczos.jpeg&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;2048&#34; height=&#34;1365&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    Orange Sky
  &lt;/figcaption&gt;


&lt;/figure&gt;






  
  











&lt;figure id=&#34;figure-violet-dusk&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/project/ipoh-skyscapes/image-gallery/violet_dusk_hubb760f67d067bc916243ef34dd4e5e56_913604_2000x2000_fit_q90_lanczos.jpeg&#34; data-caption=&#34;Violet Dusk&#34;&gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/project/ipoh-skyscapes/image-gallery/violet_dusk_hubb760f67d067bc916243ef34dd4e5e56_913604_2000x2000_fit_q90_lanczos.jpeg&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;2048&#34; height=&#34;1365&#34;&gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    Violet Dusk
  &lt;/figcaption&gt;


&lt;/figure&gt;

</description>
    </item>
    
    <item>
      <title>On Coffee</title>
      <link>https://www.ashwinnarayan.com/project/coffee/</link>
      <pubDate>Sat, 22 May 2021 10:08:54 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/project/coffee/</guid>
      <description>&lt;p&gt;As a beverage, coffee smells incredible, keeps you awake and alert, and might even improve your working memory. But its chemical effects on the body are only a small part of why coffee means so much to me. For me, coffee is also a social beverage. Many of the most amazing conversations that I&amp;rsquo;ve had at work were over coffee. Brew a cup, grab a seat, and the ideas start flowing. If alcohol is a crowbar that pries open the doors of conversation, then coffee is a lock picking kit. With a bit of skill, it makes the doors spring open without any brute force.&lt;/p&gt;
&lt;p&gt;But the most important aspect of coffee is the routine that it brought into my life over the last year. Nearly every morning, I grab a light breakfast from a nearby bakery, brew myself a pour-over from fresh, hand-ground beans before sitting down at my table to reflect on, write about and plan out the rest of my day. This routine played an essential part in keeping me sane during the last year and a half of on and off lockdowns and other restrictions caused by the global pandemic. To me, coffee represents a small island of peace—a few moments of calm thought before I head out into the chaos that is the world outside.&lt;/p&gt;
&lt;p&gt;My taste in coffee has evolved over the years. Instant coffee was my go-to (blasphemy!) during the first year of my Ph.D. This changed after a friend brought back a sample of Vietnamese coffee and a Phin filter after his holiday in the country. Since then, I&amp;rsquo;ve experimented with several types of brewing apparatus, including many of the usual suspects like the Chemex, Moka Pot, and the Aeropress. Eventually, I found that the Hario V60 fit my life the best, and I built my morning routine around it.&lt;/p&gt;
&lt;h2 id=&#34;my-morning-coffee-recipe&#34;&gt;My Morning Coffee Recipe&lt;/h2&gt;
&lt;h3 id=&#34;materials&#34;&gt;Materials&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;Hario V60 and filter paper.&lt;/li&gt;
&lt;li&gt;Whole coffee beans.&lt;/li&gt;
&lt;li&gt;Weighing scale.&lt;/li&gt;
&lt;li&gt;Boiling water.&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id=&#34;technique&#34;&gt;Technique&lt;/h3&gt;

&lt;div style=&#34;position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden;&#34;&gt;
  &lt;iframe src=&#34;https://www.youtube.com/embed/zGvus0rwRv8&#34; style=&#34;position: absolute; top: 0; left: 0; width: 100%; height: 100%; border:0;&#34; allowfullscreen title=&#34;YouTube Video&#34;&gt;&lt;/iframe&gt;
&lt;/div&gt;

</description>
    </item>
    
    <item>
      <title>Messages from Demon Slayer: Kimetsu no Yaiba</title>
      <link>https://www.ashwinnarayan.com/post/messages-from-demon-slayer/</link>
      <pubDate>Thu, 20 May 2021 14:33:00 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/messages-from-demon-slayer/</guid>
      <description>&lt;div class=&#34;alert alert-note&#34;&gt;
  &lt;div&gt;
    &lt;strong&gt;Spoiler Warning:&lt;/strong&gt; Contains spoilers for all of season 1.
  &lt;/div&gt;
&lt;/div&gt;
&lt;h2 id=&#34;tanjiro-kamado-the-inspiring-stoic-hero&#34;&gt;Tanjiro Kamado, The Inspiring Stoic Hero&lt;/h2&gt;
&lt;p&gt;Demon Slayer: Kimetsu no Yaiba had many messages that resonated with me. At the top of the list is the story of the Stoic hero that takes responsibility for his life and meets challenges with grace. Tanjiro Kamado has tragedy and death forced on him by events that were beyond his control. Muzan killed his whole family except for his sister, who was turned into a demon. It was clear that he was horrified and angry when he saw what happened to his family. But instead of becoming bitter, he accepts and channels his emotions into positive action. He nurtures his drive to prevent the same tragedy from affecting anyone else by training to become a demon slayer himself. He takes responsibility for the things that happened to him, even though it was not his fault.&lt;/p&gt;
&lt;p&gt;However, despite being motivated by a strong desire to prevent demons from killing people, Tanjiro never loses sight of his own humanity. This shows in most of his interactions with the other characters in the story. Most people who meet him are left inspired and comforted. However, his brilliant personality shines through the most during his interactions with demons. He feels for the demons, who were often made against their own will by Muzan. At times, he feels respect for their skills - like during the fight with the drum-wielding, gravity-bending demon.  And in their final moments, Tanjiro often chooses to comfort the demons he killed rather than look at them with anger or disgust. The most impactful moment for me was when he switched techniques mid-attack to lessen the pain for a demon who was just enslaved by Rui.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;gentle-kill.png&#34; alt=&#34;screenshot-gentle&#34;&gt;&lt;/p&gt;
&lt;p&gt;I think Tanjiro&amp;rsquo;s character resonated with me so much because he has many similarities to the ideal version of me in my head that I aspire to be. I have run away from the problems in my life many times, feeling overwhelmed or terrified. Most of the time, running away did not help. When reflecting on how I could have handled these situations better, I&amp;rsquo;ve often wished I could face life&amp;rsquo;s challenges with as much equanimity and optimism as Tanjiro does.&lt;/p&gt;
&lt;p&gt;Seeing Tanjiro grow by repeatedly facing terrifying challenges that were sometimes a little beyond his ability was the best part of the show for me. He&amp;rsquo;s not afraid to ask for help when challenges are overwhelming, and he gives it his best shot every time. Towards the end of the first season, I found myself drawing strength from his character. Indeed, the challenges in Tanjiro&amp;rsquo;s story are carefully curated for plot reasons. However, I think that the real message in the story is that you can choose to take on the right challenges that will help you, sometimes with the help of a trusted mentor.&lt;/p&gt;
&lt;h2 id=&#34;listening-to-the-voice-in-my-heart&#34;&gt;Listening to the Voice in My Heart&lt;/h2&gt;
&lt;p&gt;Another part of Tanjiro&amp;rsquo;s character that struck a chord with me was his enthusiastic recommendation to &amp;ldquo;listen to the voice in your heart .&amp;rdquo;&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;listen-to-the-heart.png&#34; alt=&#34;screenshot-listen-to-the-heart&#34;&gt;&lt;/p&gt;
&lt;p&gt;In my early twenties, I was heavily influenced by rationalist/skeptic literature. Convinced that emotions and feelings were irrational and sometimes unnecessary, I grew used to ignoring them. Instead, I would try to do the right thing as defined by rational analysis. This led to me making a lot of &amp;ldquo;right&amp;rdquo; but unsatisfying decisions. I&amp;rsquo;ve recently grown to realize that living my life in this way is deeply unfulfilling. These days, I think of my feelings as a sense - similar to touch or hearing - that tells me how to live a life that I will find enjoyable and fulfilling. The sense warns me when something I do doesn&amp;rsquo;t quite sit right with my internal values and makes me feel good when it fits. By stifling this sense, I realized that I was basically suppressing a core part of my personality. &amp;ldquo;Listening to the voice in my heart&amp;rdquo; is such a poetic way to express this idea. Indeed, once I started listening to my heart more, I found life so much more colorful and satisfying. I started enjoying social events more and finding more joy in getting to know people. Sometimes, I still think that I don&amp;rsquo;t listen to my heart&amp;rsquo;s voice as much as I should.&lt;/p&gt;
&lt;h2 id=&#34;special-mentions&#34;&gt;Special Mentions&lt;/h2&gt;
&lt;p&gt;Apart from the messaging, I also enjoyed the creative powers of the demons. The spacetime bending drum demon and the &amp;ldquo;arrow&amp;rdquo; demon was particularly inventive and well-executed. Zenitsu is an interesting character. Despite being annoying at times (most of the time?), I cannot deny being wowed by his first on-screen kill. Of course, Episode 19 is the star of the first season. The build-up was long and slightly tested my patience, but it was so worth it. It was probably the most satisfying on-screen anime fight scene that I&amp;rsquo;ve watched with a slow build and a spectacular, climactic finish.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;hinokami-kagura.png&#34; alt=&#34;hinokami-kagura&#34;&gt;&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Why I Stopped Reading the News During the Pandemic</title>
      <link>https://www.ashwinnarayan.com/post/stop-reading-the-news/</link>
      <pubDate>Mon, 10 May 2021 16:17:00 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/stop-reading-the-news/</guid>
      <description>&lt;p&gt;Growing up, I was frequently reminded of the importance of reading the news. My family was always subscribed to at least one (physical) newspaper, and magazine subscriptions were not uncommon. A year into the COVID-19 pandemic, however, I&amp;rsquo;ve decided not to read the news anymore. Most local news websites are blocked on all my devices, in addition to aggregators and social media websites where links to these news sites are shared.&lt;/p&gt;
&lt;p&gt;The reason? Mental health. Over the last few months, I found myself repeatedly checking news sites for updates related to the COVID pandemic. The habit got worse as the situation started to go downhill in India. On most days, I spent between 30 and 45 minutes in bed in the mornings, doom-scrolling on various news sites.&lt;/p&gt;
&lt;p&gt;Negative news sells. And as the pandemic worked its way around the globe, the news articles often only highlighted the worst aspects. I found myself increasingly obsessed with the negative news. Toxic, misinformed, or vitriolic comments on news websites that allowed them didn&amp;rsquo;t help much either.&lt;/p&gt;
&lt;p&gt;I noticed that I&amp;rsquo;d started feeling a general sense of anxiety and unease. Sometimes, I&amp;rsquo;d feel a sense of danger and hostility during benign activities like walking to work.&lt;/p&gt;
&lt;p&gt;After failed experiments with partial blocks and gradual weaning, I realized that the only real solution was to just stop reading the news every day. A few days ago, I went through the headlines on a website I frequented and asked myself:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Are there any actions I could have taken from knowing this news that could have made my life better?&lt;/li&gt;
&lt;li&gt;What if I only found out about this a month from now?&lt;/li&gt;
&lt;li&gt;What if I never read this article?&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;I realized that for 99% of the headlines, there wasn&amp;rsquo;t anything useful I could do after I read it. And for most of the headlines, it would not matter at all if I never read it.&lt;/p&gt;
&lt;p&gt;The small 1% of deadlines that actually mattered were announcements about the changes in COVID rules (group sizes, travel restrictions, etc.).  For these announcements, I found that my needs were met by subscriptions to the official government WhatsApp and telegram groups and a quick check of the main website. These sources gave me the information I needed without any emotional messaging and interpretation that news websites offered.&lt;/p&gt;
&lt;p&gt;Have your stress levels increased during the pandemic? If you&amp;rsquo;ve been reading a lot of news online, that could be part of the problem. Consider avoiding, or failing that, blocking these websites from your devices.&lt;/p&gt;
&lt;p&gt;Personally, I found my days calmer, happier, and more productive after I cut down my news consumption.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;If you&amp;rsquo;re looking for an easy way to block websites across all your devices, I can recommend the tool called 
&lt;a href=&#34;https://freedom.to&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Freedom&lt;/a&gt;. I bought a lifetime membership a year ago at the start of the pandemic. It&amp;rsquo;s probably the best investment that I made in myself last year.&lt;/em&gt;&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Digital Minimalism</title>
      <link>https://www.ashwinnarayan.com/post/digital-minimalism/</link>
      <pubDate>Thu, 03 Dec 2020 10:45:29 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/digital-minimalism/</guid>
      <description>&lt;h1 id=&#34;about-the-book&#34;&gt;About the Book&lt;/h1&gt;
&lt;p&gt;As a heavy user of computer technology for over a decade, I&amp;rsquo;ll be the first defend its benefits. My familiarity with the internet is responsible for a significant chunk of my knowledge and much of my critical thinking abilities. Through personalities like Carl Sagan and Michael Shermer, it also played a big part in me developing an intense interest in science and eventually pursuing a career in it.&lt;/p&gt;
&lt;p&gt;When something is so useful, you tend to be slow to notice its downsides. In 2016, I started to feel that my technology use was filling large chunks of my time with un-productive habits, preventing me from doing many of the cool things that the internet told me was possible. I often found myself 
&lt;a href=&#34;https://www.washingtonpost.com/lifestyle/wellness/coronavirus-doom-scrolling-stop/2020/07/29/2c87e9b2-d034-11ea-8d32-1ebf4e9d8e0d_story.html&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;doom scrolling&lt;/a&gt; on websites like Facebook, Instagram or reddit at the end of my workday and during weekends. My habit of mindless browsing was taking away time that I could be putting into developing new skills that I wanted to develop. In other words, I was starting to feel like I was losing control over my time.&lt;/p&gt;
&lt;p&gt;I found Digital Minimalism when I was searching for methods that would help me stay on task when I was using tech. The book contains very practical advice on how to change habits surrounding technology usage and halped me free up large chunks of my time for pursuits that I find more satisfying.&lt;/p&gt;
&lt;p&gt;If you&amp;rsquo;re the kind of person that finds themselves deep in a reddit thread about annoying habits of co-workers ten minutes after opening up your laptop for responding to an email, this book might help. For me, the most useful feature of the book is how it builds a coherent theory of how humans interact with technology. Newport takes many different negative aspects of unstructured technology use, and brings it together under one theoretical framework and uses this framework to dispense specific advice about how to make things better.&lt;/p&gt;
&lt;h1 id=&#34;summary&#34;&gt;Summary&lt;/h1&gt;
&lt;h2 id=&#34;humans-are-biologically-wired-in-certain-ways&#34;&gt;Humans are Biologically Wired in Certain Ways&lt;/h2&gt;
&lt;p&gt;The mentions three key things that human brains have evolved to find satisfaction in.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Real-World Social Interactions:&lt;/strong&gt; Interacting with people in the real world involves processing a dense, &amp;ldquo;high-bandwidth&amp;rdquo; stream of information that engages multiple senses. Newport suggests that as a social species, humans have evolved to find satisfaction in such high-bandwidth social interactions.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Occasional Solitude:&lt;/strong&gt; Newport cites scientific studies to build the case that the brain does important types of reflective thinking when you are alone and that this might be very important to develop as a person. He also gives some case studies of famous people who have found value in developing new ideas for their work in solitude.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Building Physical Things:&lt;/strong&gt; As a species that evolved to use tools, Newport argues that humans are wired to find satisfaction in seeing physical consequences of our efforts.&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;modern-tech-optimizes-for-capturing-and-holding-human-attention&#34;&gt;Modern Tech Optimizes for Capturing and Holding Human Attention&lt;/h2&gt;
&lt;p&gt;The book highlights the fact that many technologies such as mobile apps and social media websites are precisely engineered to capture and maintain as much of our attention as possible. Since the users&amp;rsquo; attention is the source of revenue for many apps and websites, it is natural for them to optimize themselves for how much attention they can capture.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Social Interactions:&lt;/strong&gt; Social media captures your attention by providing social approval (which the brain craves) but through low bandwidth channels such as &amp;ldquo;likes&amp;rdquo; or &amp;ldquo;upvotes&amp;rdquo;. The book argues that these signals of social approval keep our brains engaged in the app, leaving us with less time for real social interactions but leave us dissatisified because of their low bandwidth nature.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Solitude:&lt;/strong&gt; Constantly being &amp;ldquo;plugged-in&amp;rdquo; into these apps and websites prevents our brains from getting solitude from time to time, depriving it of time to reflect. This could have negative effects such as increasing anxiety and less time for developing creative ideas.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Physical Hobbies:&lt;/strong&gt; Time spent using tech also necessarily means less time for developing hobbies that involve building physical things. Newport argues that activities like programming or building websites don&amp;rsquo;t quite satisfy our brains in the same way as building a fence or a house.&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;the-books-recommendation&#34;&gt;The Book&amp;rsquo;s Recommendation&lt;/h2&gt;
&lt;p&gt;To mitigate these negative affects of technology, the book recommends adopting a philosophy of technology use that guides which technologies to adopt and which to avoid. This requires first getting a good idea of your values and goals in life and only adopting the use of technologies that align with your values and goals.&lt;/p&gt;
&lt;p&gt;The book warns that one-off hacks like switching to a smart-phone or blocking time-wasting websites won&amp;rsquo;t work on their own without an over-arching philosophy.&lt;/p&gt;
&lt;h3 id=&#34;digital-minimalism&#34;&gt;Digital Minimalism&lt;/h3&gt;
&lt;p&gt;Cal Newport&amp;rsquo;s calls his preferred philosophy of technology use &lt;strong&gt;Digital Minimalism&lt;/strong&gt;. Digital minimalism starts with a one month technology detox during which you cut out all non-essential technology from your life. The month is used to evaluate whether any of the tech you used to use actually aligned with your goals and values.&lt;/p&gt;
&lt;h3 id=&#34;recommended-values&#34;&gt;Recommended Values&lt;/h3&gt;
&lt;p&gt;The book also goes one step further and uses what science knows about human nature to recommend some specific values that may be useful to adopt when dealing with technology.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Prioritize Real-World Social Interaction:&lt;/strong&gt; Use technology to increase the amount of time that you spend on face-to-face interactions with people.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Schedule Solitude:&lt;/strong&gt; Use the time that may be gained from cutting out distracting tech, spend more time on your own and let your brain get a healthy amount of time to reflect quietly on things.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Physical Hobbies:&lt;/strong&gt; Consider adopting hobbies that involve creating and shaping material with the hands.&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id=&#34;verify-before-trusting&#34;&gt;Verify Before Trusting&lt;/h3&gt;
&lt;p&gt;Since the source of income for much of the tech that we use is our attention, it will naturally optimize for capturing and holding our attention for as long as possible even if it is not in our interest. So the book recommends treating all new tech first with suspcion and letting the tech into our lives only after we have determined that it aligns with our goals and values. Periodically evaluating tech that you&amp;rsquo;ve already let in to make sure that its behaviour has not changed may also be a good idea.&lt;/p&gt;
&lt;h1 id=&#34;closing-thoughts&#34;&gt;Closing Thoughts&lt;/h1&gt;
&lt;p&gt;I think that the book gets right the idea that we need a philosophy of technology use so that it does not prevent us from achieving our goals. However, I think that some of the recommended values may be specific to the author. In particular, I find that writing code or making PCBs often scratch my creative itch just fine. In fact, I have an aversion to sports or things that make me feel physically winded or sweaty. I think that the most valuable takeaway from the book is that it&amp;rsquo;s a good idea to make sure that the technology and tools that you use align with your values and goals. What those values and goals should be is up to you.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Music</title>
      <link>https://www.ashwinnarayan.com/project/music/</link>
      <pubDate>Mon, 25 May 2020 14:10:18 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/project/music/</guid>
      <description>&lt;h2 id=&#34;may-31-2020&#34;&gt;May 31, 2020&lt;/h2&gt;
&lt;!--  --&gt;
&lt;h2 id=&#34;april-17-2020&#34;&gt;April 17, 2020&lt;/h2&gt;

&lt;div style=&#34;position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden;&#34;&gt;
  &lt;iframe src=&#34;https://www.youtube.com/embed/LIPJZcSUjRE&#34; style=&#34;position: absolute; top: 0; left: 0; width: 100%; height: 100%; border:0;&#34; allowfullscreen title=&#34;YouTube Video&#34;&gt;&lt;/iframe&gt;
&lt;/div&gt;

&lt;h2 id=&#34;april-11-2020&#34;&gt;April 11, 2020&lt;/h2&gt;

&lt;div style=&#34;position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden;&#34;&gt;
  &lt;iframe src=&#34;https://www.youtube.com/embed/RdU1eXyRhU0&#34; style=&#34;position: absolute; top: 0; left: 0; width: 100%; height: 100%; border:0;&#34; allowfullscreen title=&#34;YouTube Video&#34;&gt;&lt;/iframe&gt;
&lt;/div&gt;

&lt;h2 id=&#34;earlier&#34;&gt;Earlier&lt;/h2&gt;
&lt;!--  --&gt;
&lt;!--  --&gt;</description>
    </item>
    
    <item>
      <title>Artwork</title>
      <link>https://www.ashwinnarayan.com/project/artwork/</link>
      <pubDate>Mon, 25 May 2020 13:41:05 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/project/artwork/</guid>
      <description>&lt;h2 id=&#34;my-attempt-at-following-a-bob-ross-tutorial&#34;&gt;My Attempt at Following a Bob Ross Tutorial&lt;/h2&gt;
&lt;p&gt;So after getting my new iPad, I tried to work through one of Bob Ross&amp;rsquo;s videos as soon as I could. Here&amp;rsquo;s my attempt at the one from season 14 episode 1.&lt;/p&gt;
&lt;p&gt;In the spirit of Bob&amp;rsquo;s technique, I tried making up stories about the things in my painting.&lt;/p&gt;





  
  











&lt;figure &gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/project/artwork/bob-ross-1_hu7158625685c9fc152a73540713f672a7_98672_2000x2000_fit_q90_lanczos.jpg&#34; &gt;


  &lt;img data-src=&#34;https://www.ashwinnarayan.com/project/artwork/bob-ross-1_hu7158625685c9fc152a73540713f672a7_98672_2000x2000_fit_q90_lanczos.jpg&#34; class=&#34;lazyload&#34; alt=&#34;&#34; width=&#34;1080&#34; height=&#34;1350&#34;&gt;
&lt;/a&gt;



&lt;/figure&gt;

&lt;p&gt;The empty boat was used by a traveler to cross the water body. But he didn&amp;rsquo;t secure it well enough. Now he has to walk for several hours to get home.
The sky diver opened his parachute too late (he did not account for the mountain&amp;rsquo;s elevation) and will probably crash into the mountain too fast. Hopefully, the snow will cushion his fall.
There&amp;rsquo;s a lone hiker on the mountain. He misjudged the slope. Shortly after the moment captured by the painting, he slips and slides all the way down. Let&amp;rsquo;s hope he&amp;rsquo;s able to call for help using his radio.&lt;/p&gt;
&lt;p&gt;The mountain goat is enjoying the fabulous day.&lt;/p&gt;
&lt;p&gt;An SR-71 Blackbird is flying by at greater than Mach 3. It&amp;rsquo;s sonic boom might trigger a minor avalanche.&lt;/p&gt;
&lt;p&gt;Am I doing this right?&lt;/p&gt;
&lt;h2 id=&#34;anime-style-character-drawing&#34;&gt;Anime Style Character Drawing&lt;/h2&gt;
&lt;p&gt;&lt;img src=&#34;anime-drawing.jpg&#34; alt=&#34;anime-drawing&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;the-cell-phone-tower&#34;&gt;The Cell Phone Tower&lt;/h2&gt;
&lt;p&gt;A drawing of the evening sky with a cell phone tower visible. This one was a gift to my fiancee.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;phone_tower.jpg&#34; alt=&#34;cell-phone-tower&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;diyas&#34;&gt;Diyas&lt;/h2&gt;
&lt;p&gt;A painting of lit diyas (diwali lamps).&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;diwali_lamps.jpg&#34; alt=&#34;cell-phone-tower&#34;&gt;&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>On the Effective Use of TODO Lists</title>
      <link>https://www.ashwinnarayan.com/post/what-i-learned-about-todo-lists/</link>
      <pubDate>Fri, 22 May 2020 13:30:50 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/what-i-learned-about-todo-lists/</guid>
      <description>&lt;h2 id=&#34;introduction&#34;&gt;Introduction&lt;/h2&gt;
&lt;p&gt;Like many countries around the world, Singapore entered a lockdown (a &amp;ldquo;circuit-breaker&amp;rdquo; to use the local terminology) on April 4 to stem the rapid spread of COVID-19. Knowing how easy it is to get distracted from work and lose productivity at home, I made a commitment to myself at the start of the lockdown to use the extra time to improve myself. Specifically I wanted to improve my workflows for many of my daily tasks.&lt;/p&gt;
&lt;p&gt;A key part of the effort is my renewed commitment to TODO lists. I&amp;rsquo;ve made several attempts to integrate TODO lists as a habit into my life before, but the habit has never stuck. As a result, I use TODO lists quite loosely - &lt;em&gt;i.e.&lt;/em&gt; when things get super hectic and I have no choice but to use them to keep me sane. Otherwise, I simply remember the big picture of what I want to get done. While this has led to me forgetting to do the odd task, I felt that my overall productivity was not significantly impacted. If I really want to remember something, I might stick a Post-It note on my work desk. However, I decided recently that this was not good enough for me for two reasons:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;I want to improve myself as a person.&lt;/li&gt;
&lt;li&gt;I want to take on more responsibilities and work and this is only possible if I improve this part of myself.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;So about a week into the lockdown, I decided to use TODO lists to track all my tasks for the next 30 days. If I saw real improvements in these 30 days, I&amp;rsquo;d keep the system. If not, I&amp;rsquo;d try to find a better one. I put some weight into the commitment by purchasing for myself a premium account in the 
&lt;a href=&#34;https://todoist.com/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;todoist app&lt;/a&gt;. While the system felt awkward and cumbersome at the start, I began to notice tangible improvements at the two week mark. With a little experimentation, I was able to optimize TODO lists to work for me. Here&amp;rsquo;s what I learned from the 30 day experiment.&lt;/p&gt;
&lt;h2 id=&#34;1-believe-in-the-system&#34;&gt;1. Believe in the System&lt;/h2&gt;
&lt;p&gt;In all my previous attempts, I started with a lot of skepticism about the effectiveness of using TODO lists. This time, I decided that I was going to proceed as though it was going to work. This seemed to make a big difference in how the experiment worked out. I observed straight away that I was more motivated to find ways to make the system work for me. In the past, I&amp;rsquo;d give up on the method when some small obstacle popped up (the app not having some small feature that I wanted for instance).&lt;/p&gt;
&lt;h2 id=&#34;2-use-it-for-everything&#34;&gt;2. Use it for Everything&lt;/h2&gt;
&lt;p&gt;I read that this is similar to David Allen&amp;rsquo;s advice in his book &amp;ldquo;Getting Things Done&amp;rdquo;. It does help to capture in the list absolutely everything that you want to get done. Doing this meant that I did not need to keep a running list of all my tasks in my brain. I didn’t realize that keeping my task list in my head was generating a low background radiation of anxiety in my brain until I stopped doing it. Capture everything in your task list - both personal and work-related.&lt;/p&gt;
&lt;h2 id=&#34;3-use-a-cross-platform-system&#34;&gt;3. Use a Cross-Platform System&lt;/h2&gt;
&lt;p&gt;I&amp;rsquo;ve experimented with systems like the bullet journal before. While I do like the feeling of having a physical notebook to write down tasks in, I found that I became too dependent on the notebook. If I forgot to bring the notebook anywhere (which can happen), I got lost. Using a cross platform task tracking app that works on both the desktop and on the phone is more convenient and ensures that you&amp;rsquo;ll have your task list with you pretty much wherever you go.&lt;/p&gt;
&lt;h2 id=&#34;4-check-the-list-before-starting-work&#34;&gt;4. Check the List Before Starting Work&lt;/h2&gt;
&lt;p&gt;Previously, I&amp;rsquo;d just sit down and start working on whatever floated to the top of my head at that moment. While this works great when you don&amp;rsquo;t have that many things to do, it may result in small things being forgotten and pushed to the last minute. In addition to making me more intentional about what I was doing, checking my list before starting work also made me more likely to finish off more of the small tasks before they accumulated to annoying levels.&lt;/p&gt;
&lt;h2 id=&#34;5-theres-a-time-and-place-for-specificity&#34;&gt;5. There&amp;rsquo;s a Time and Place for Specificity&lt;/h2&gt;
&lt;blockquote&gt;
&lt;p&gt;There&amp;rsquo;s a time and place for everything, but not now. &lt;em&gt;-Professor Oak&lt;/em&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;The most important thing I learned is to choose the right level of specificity when entering tasks into the list. My first instinct was to overdo it. I made full use of the fact that you could nest subtasks pretty deep in todoist (4 levels) and wrote big picture items into the list and started breaking it down into smaller steps. Then I started doing the task and found out that the steps that I wrote down were either too optimistic completely unnecessary. However, when I tried only writing down the big picture tasks, they became too big and scary and I didn’t want to touch them. In the end what worked for me was to write down only big picture things when I first enter the task into the system. When I start working on the task, I click into it and start adding sub-tasks.&lt;/p&gt;
&lt;p&gt;Another thing I learned about &amp;ldquo;sub-tasking&amp;rdquo; was not to add sub-tasks too far into the future. The further ahead I planned the more my plan deviated from reality and the more I had to delete what I wrote and replan.&lt;/p&gt;
&lt;h2 id=&#34;6--choose-the-right-level-of-specificity&#34;&gt;6.  Choose the Right Level of Specificity&lt;/h2&gt;
&lt;p&gt;On a related note to point 5, I recommend experimenting a bit to find the right level of task specificity for the subtasks. I experimented with breaking up large tasks into subtasks that took from 1 minute all the way up to a few hours. I found subtasks that took between 5 and 15 minutes to be the most rewarding. Anything smaller added too much overhead to the tasks. Anything longer exponentially decreased the probability that I’d start working on that task.&lt;/p&gt;
&lt;p&gt;Choosing a consistent level of specificity also solved the problem of unequal weighting of tasks for me. Checking off tasks is actually quite rewarding on its own. When the reward for checking off one big task that took 5 hours to do was the same as the reward for a two minute task, it gave me less motivation to tackle the big tasks. Once I started choosing a consistent level of specificity for the tasks that I checked off, larger tasks became naturally more rewarding than the smaller tasks and my productivity on larger tasks improved as a result.&lt;/p&gt;
&lt;h2 id=&#34;7-consider-gamification&#34;&gt;7. Consider Gamification&lt;/h2&gt;
&lt;p&gt;There’s some evidence that gamification of tasks can help improve the motivation for completing them. I don’t think that gamification can work as a base motivation but it may help a little with the day to day motivation. For me, the simple points system on todoist adds a small touch of motivation without adding too much overhead.&lt;/p&gt;
&lt;h2 id=&#34;8-attach-it-to-your-bedtime-routine&#34;&gt;8. Attach it to Your Bedtime Routine&lt;/h2&gt;
&lt;p&gt;Checking the list one last time before turning in is really helpful. It feels good to clear the schedule for the day and have a sense of resolution. I recommend doing this even if you haven&amp;rsquo;t finished everything on the list. Simply reschedule the unfinished items to the next day but get to zero tasks remaining for the day. Integrating it into my bedtime routine has also helped with my effort to avoid browsing the phone mindlessly in bed before going to sleep. I set a simple rule for myself: Once I clear the day&amp;rsquo;s list, I can&amp;rsquo;t use the phone anymore and must go to sleep.&lt;/p&gt;
&lt;h2 id=&#34;9-dont-let-perfect-be-the-enemy-of-good&#34;&gt;9. Don&amp;rsquo;t Let Perfect be the Enemy of Good&lt;/h2&gt;
&lt;p&gt;This is related to me giving up on systems too early. I realized that I tend to try and find the perfect process to do things before even trying. While this is useful in many situations, it has sometimes led to me not doing things in the first place. If you have a proclivity for perfection, don&amp;rsquo;t let it get in the way of you trying new but imperfect systems. Just remember that you can always optimize later. The more important thing is to get started.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Investing in the Stock Market: A Scientist&#39;s View</title>
      <link>https://www.ashwinnarayan.com/post/investing-and-personal-finance/</link>
      <pubDate>Sat, 23 Nov 2019 17:50:00 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/investing-and-personal-finance/</guid>
      <description> &lt;!-- 1. Read a lot about how investments should be a part of personal finance.
 2. Most articles I read were a little patchy. 
 3. I like looking at things from first principles and know how things work. 
 4. Thought it was a good idea to know how things worked before starting to invest. 
 5. Going to summarize what I learned and how I made sense of investments before I started.
 6. Will talk about the pros and cons.
 7. How to decide on an investment strategy.
 8. Writing for people like me who have heard of the importance of investing but haven&#39;t started yet because they have not read a good high level overview of the material and don&#39;t have a good intuitive understanding of how the stock market works. 
 9. I want to explore the rationale behind investing and take a look at the advantages and disadvantages too. Like most things, it&#39;s not for everyone and there are some questions you can ask to find out if you&#39;re prepared to start investing or not. 

To understand the rationale behind investing in the stock market, the story begins with inflation. 
 1. Inflation is the process by which cash decreases in value over time. Healthy economies need to have a well chosen rate of inflation. 
 2. If you hold cash, the amount of stuff you can buy with the cash decreases over time. 
 3. So you need to find a way to make the cash retain or increase in value over time. 
 4. The most common way to do this is interest. Banks charge an interest rate when they lend you money because if the money is returned without interest, by the time you&#39;ve paid back the loan, the bank has less money than it had before. 
 5. Banks give you an interest rate in most savings accounts for the same reason. Countries set the interest rates of the banks based on the current rate of inflation.  --&gt;
&lt;h2 id=&#34;introduction&#34;&gt;Introduction&lt;/h2&gt;
&lt;p&gt;Growing up in an Indian family, I had very little exposure to discussion and information about the stock market. People in India are generally less likely to invest in the stock market. Many view investments with suspicion. Indeed, most estimates put the percentage of the population that invest in stocks at 2-5% of the country&amp;rsquo;s total population [5, 6]. Unsurprisingly, investments were never really a topic of conversation in my home or in school growing up. The only remark I remember from my parents about it dismissed it as little more than gambling. School education in India is also lacking in this regard. Economics was either not taught or lumped in with other subjects such as history. I remember very little of economic theory actually being taught in school, especially for those who were aiming for engineering schools.&lt;/p&gt;
&lt;p&gt;I was introduced to the idea of investing during my PhD through some of the friends I made here in Singapore. Investing is relatively common here. It was interesting to see articles like 
&lt;a href=&#34;https://www.straitstimes.com/business/banking/1-in-3-singaporeans-do-not-invest-most-financially-unprepared-for-retirement-ocbc&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;this&lt;/a&gt; highlighting that around 33% of Singaporeans &lt;em&gt;do not&lt;/em&gt; invest. Culturally, investing enjoys relative popularity here as a way to keep ahead of inflation and to grow savings. Always the scientist, I set out to understand the underlying principles behind investing in the stock market before I started. There is no dearth of articles on the internet with advice on getting started with investing in the stock market. However, a lot of the articles that I read left me unsatisfied as a scientist. Observations - like the fact that money loses value over time - were often presented as assumptions and discussions about the benefits of investing tended to be biased towards the investor; with the central point of most articles being that investing can grow your money. While I learnt quite a bit about investing, I was left with many unanswered questions. For instance, why does the assumption that money loses value over time hold? Who benefits from a healthy stock market apart from the investors?&lt;/p&gt;
&lt;p&gt;These questions led me down a rabbit hole of academic articles about economic theory and monetary planning. I wrote this article for people who, like me, did not grow up in a culture of investing and would like to know of the &lt;em&gt;raison d&amp;rsquo;être&lt;/em&gt; of stock markets. The article contains some of the information that helped me make an informed decision about whether I should invest in the stock market.&lt;/p&gt;
&lt;h2 id=&#34;inflation-and-economic-growth&#34;&gt;Inflation and Economic Growth&lt;/h2&gt;
&lt;p&gt;The story starts with the assumption that money will lose value over time. Economists use the term inflation to refer to this phenomenon. When an economy experiences inflation, the prices of things increase over time. So, the same amount of money buys less things in the future than it buys today. Most countries experience a positive rate of inflation [4].&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;https://www.ashwinnarayan.com/img/inflation_histogram.png&#34; alt=&#34;inflation_histogram&#34;&gt;&lt;/p&gt;
&lt;p&gt;Countries consider this a good thing. In fact, some countries even engage in something called “Inflation Targeting” to make sure that the rate of inflation remains at a low but stable and positive level. But if countries are willing and able to influence the rate of inflation, why do they target a positive inflation rate? Why not target zero? Or better yet, why not target a negative inflation rate and let money increase in value over time, and reward people who save their money?&lt;/p&gt;
&lt;p&gt;Deflation is when the prices of things decrease over time. That means money becomes more valuable as time goes on. The average person might consider this a good thing. If I save up money right now and just hold on to it long enough, I’ll be able to afford that expensive home or car eventually. But this effect of delaying purchases for the future appears to have a negative effect on the overall economy. Growth slows, unemployment rises, and businesses start to shut down as demand for the things that they make decreases. Deflation also increases the risk of a deflationary spiral - in which falling demand and prices and rising unemployment becomes a runaway positive feedback loop. Many economists think that such a spiral was responsible for the Great Depression of the 1930s.&lt;/p&gt;
&lt;p&gt;Is inflation better? A high rate of inflation is also considered a bad thing. If inflation is too high, the value of people’s savings decreases too fast and wages do not increase fast enough. This results in people hoarding physical goods.  Hyper-inflation can also lead to a runaway positive feedback loop in the opposite direction.&lt;/p&gt;
&lt;p&gt;As a result, keeping the economy on track is a balancing act. Countries target an inflation rate that is in the low single digits so that there is enough of a buffer zone between the current state of the economy and deflation and use regular updates to monetary policy to prevent runaway inflation. The United States for example targets a yearly inflation rate of 2%.&lt;/p&gt;
&lt;p&gt;In other words, governments give more importance to price stability than anything else. Both deflation and high rates of inflation slow down economic growth and have negative effects while low rates of inflation offer price stability and controllability.&lt;/p&gt;
&lt;p&gt;Given that modern economies tend to prefer inflation and actively try to maintain it, holding on to money means that the value of your money will decrease (albeit slowly) over time in most countries in the world. So, if people want to keep their savings from losing value, they need to do something with their savings other than hiding it under their pillow.&lt;/p&gt;
&lt;h2 id=&#34;bank-savings-accounts&#34;&gt;Bank Savings Accounts&lt;/h2&gt;
&lt;p&gt;One way for people to save in an inflationary economy is to use a savings account in a bank that offers to periodically pay you a certain percentage of the money as interest. This is the form of savings that most people are familiar with. Some banks offer special “fixed deposit” accounts that you can put money into and take out only after a certain amount of time. If the savings account offered by the bank has a rate of interest that exceeds or is very close to the rate of inflation then your savings will keep most of their value over time. For many people this form of saving is perfectly fine. If people choose banks that are large and reliable, the risk of losing money is very low. And as long as you live within your budget, you’ll be perfectly happy person. This style of investment is good for people who are very risk averse or for people who plan to retire soon.&lt;/p&gt;
&lt;p&gt;The opportunity cost of saving money like this is of course the fact that money invested in the stock market could potentially increase in value much faster than a bank savings account will allow. For instance, the value of the stocks in Google has increased by 25% since November 2018. This beats interest rates by a large amount. But the keyword here is “potentially”. When you put money into the stock market, there is also the risk that the money can be lost - sometimes entirely. Where does this money come from and where does it go? And why do stocks offer such large potential returns? To answer these questions, I need to go into why the stock market exists in the first place.&lt;/p&gt;
&lt;h2 id=&#34;businesses-need-capital&#34;&gt;Businesses Need Capital&lt;/h2&gt;
&lt;p&gt;Starting and running a business is no small task. Businesses typically need large amounts of money to get started. They may need office space, they may need to build factories and make expensive prototypes to perfect their technology. Sometimes businesses decide to expand by improving their products or making entirely new ones. One way to finance these costs is to use bank loans. This is in fact what a lot of companies do. However, the amount of money that banks can loan out is limited. Companies also need to pay an interest on the loans. So, if the company is working on something that will not produce a profit for some time, the interest on their loans can accumulate quite fast.&lt;/p&gt;
&lt;p&gt;Somewhere along the way people had the idea to raise money from regular people instead. However, rather than having people loan the business the money, the business would offer a small chunk or a share of itself in exchange for money. Once the business becomes profitable, the person with the share would be entitled to a portion of the profits. Partial ownership also granted other benefits. The shareholder could have a say in how the company was run and help choose managers. The stock market is a place that facilitates the buying and selling of these chunks of companies (for a fee of course). The Amsterdam Stock Exchange, established in 1602 is considered the oldest such place. The price of the share of a company is determined by the forces of supply and demand. Simply put, the value of stock is what people are willing to pay for it. If people think that a stock is valuable because the the company has the potential to grow, the stock gets more expensive because the demand for the stock is higher than the supply. If people think the company has no future, the stock&amp;rsquo;s value falls as more people are trying to sell the stock, increasing its supply.&lt;/p&gt;
&lt;p&gt;Businesses benefit from this because they can quickly raise money at 0% interest. As long as they don’t part with more than 50% of the company ownership, they can even retain full control over what happens in the company. Many economists think that by letting more people participate in the economy, there is more money available for people to start businesses and make things. This leads to more growth as it encourages people make more new things and the overall ‘value’ of the economy increases (because now there are more things (knowledge, services, technology) in the economy.&lt;/p&gt;
&lt;p&gt;Most articles I’ve read talk about how investing is important because it lets you make money compared to just holding cash. But I feel that these articles are missing the more important point that having a stock market setup as a cornerstone of the world’s economic system could be the principal reason that human civilization has seen such amazing growth in knowledge and technology. This, in my view is a far more important reason to invest and to participate in the economy than the personal goal of getting more money. The stock market appears to be set up so that participating in it offers benefits to both businesses and the investors even if they do not know and care about the meta-goal of sustained growth of human civilization.&lt;/p&gt;
&lt;h2 id=&#34;the-stock-market-gains-value-in-the-long-run&#34;&gt;The Stock Market Gains Value in the Long Run&lt;/h2&gt;
&lt;p&gt;While the sustained growth of human civilization is a fine goal, the most pertinent question for the individual investor is the risk of losing their money. If I buy stocks in a certain company and it folds, I do not get most of the money back. So what&amp;rsquo;s in it for the individual investor?&lt;/p&gt;
&lt;p&gt;While single stocks can lose value over time and even drop to zero, the stock market as a whole tends to rise in value over time. Stock markets have indices that track the value of a set of stocks over time. In a pattern that has remained consistent for decades, the market as a whole tends to gain value in the long run. While economic recessions like the one that happened in 2008 can reduce the value of stocks in the short term, in the long run (over the course of tens of years), they gain in value. The graph below shows the value of the total US stock market as represented by the Wilshire 5000 Price Index over time [8].&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;https://www.ashwinnarayan.com/img/price_index.png&#34; alt=&#34;price_index&#34;&gt;&lt;/p&gt;
&lt;p&gt;Many such indices in other countries show a similar trend. For individuals then, the incentive is that even by &amp;ldquo;passively&amp;rdquo; investing in the entire stock market (a facility available through something called index funds) their savings grow over time with a high probability. For companies that are listed on the stock market, the incentive is that they have access to large amounts of capital to fund their growth. Individual companies can fail and try again. While individual investors can never reduce the probability of losing all their money to 0, they can reduce it significantly by buying and holding a diverse set of stocks.&lt;/p&gt;
&lt;h2 id=&#34;the-other-side-of-the-coin&#34;&gt;The Other Side of the Coin&lt;/h2&gt;
&lt;p&gt;This is of course not the complete story. I’ve only mentioned the bare essentials of the system. There are other ingredients needed to ensure that the growth generated by this economic system is sustainable. One of the most obvious problems is that the shareholders of a company may &lt;em&gt;only&lt;/em&gt; care about making money. This means that the company would try to maximise profit above all else in a way that can be harmful for humanity as a whole. Part of the reason is that economic activity generates costs apart from that of labor and raw materials. These external costs - such as the generation of planet warming greenhouse gases - means that there is a need for well desiged regulations that ‘bake in’ these external costs into the cost of running businesses. Implementing things like a carbon tax or a pollution cleanup tax will probably be necessary in the coming years to make sure that our economic activity does not mess up the planet that we live in.&lt;/p&gt;
&lt;p&gt;So, with some well-planned regulations, carefully controlled inflation and thriving stock market humanity should be set for growth - at least until the next disruptor comes along. An AI singularity perhaps?&lt;/p&gt;
&lt;h2 id=&#34;references&#34;&gt;References&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;a href=&#34;https://en.wikipedia.org/wiki/Deflation&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Wikipedia Article on Deflation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.nber.org/papers/w8057.pdf&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Friedman, Benjamin M. Monetary policy. No. w8057. National Bureau of Economic Research, 2000.&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.federalreserve.gov/boarddocs/speeches/2002/20021121/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Remarks by Governor Ben S. Bernanke&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.cia.gov/library/publications/the-world-factbook/rankorder/2092rank.html&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Inflation Rates by Country, CIA World Factbook&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://qz.com/india/628232/indians-have-a-love-hate-relationship-with-stock-markets-says-ceo-of-asias-first-stock-exchange/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Indians have a love-hate relationship with stock markets, says CEO of Asia’s first stock exchange&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.livemint.com/Money/kKNhSzmjqbQa7VOuLRWedJ/Majority-of-states-have-very-few-stock-market-investors.html&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Majority of states have very few stock market investors&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.straitstimes.com/business/banking/1-in-3-singaporeans-do-not-invest-most-financially-unprepared-for-retirement-ocbc&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;1 in 3 Singaporeans does not invest, most financially unprepared for retirement: OCBC survey&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://fred.stlouisfed.org/series/WILL5000PR&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Wilshire 5000 Price Index Historic Data&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;
</description>
    </item>
    
    <item>
      <title>Building a Simple Telegram Bot Using Google Cloud Functions</title>
      <link>https://www.ashwinnarayan.com/post/gcp-telegram-bot/</link>
      <pubDate>Thu, 06 Jun 2019 13:59:15 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/gcp-telegram-bot/</guid>
      <description>&lt;p&gt;Many websites use bots to automate tasks and add useful (and sometimes harmful) functionality. For instance, there are reddit bots that can help you 
&lt;a href=&#34;https://www.reddit.com/r/stabbot/comments/72irce/how_to_use_stabbot/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;stabilize shaky videos&lt;/a&gt;, 
&lt;a href=&#34;https://www.reddit.com/r/RemindMeBot/comments/24duzp/remindmebot_info/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;remind you of events&lt;/a&gt; or even 
&lt;a href=&#34;https://www.reddit.com/user/goodbot_badbot&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;vote on the usefulness of other bots&lt;/a&gt;. 
&lt;a href=&#34;https://telegram.org/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Telegram&lt;/a&gt; - an instant messaging service similar to WhatsApp - lets you create and manage bots on their platform using their 
&lt;a href=&#34;https://core.telegram.org/bots/api&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Bot API&lt;/a&gt;. Bots on Telegram are officially identified and provide fun and useful services. Last month, while exploring Google Cloud Platform after getting some free student credits, I came across 
&lt;a href=&#34;https://cloud.google.com/functions/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Google Cloud Functions&lt;/a&gt;. I realized that this hammer was perfect for the nail of setting up a simple Telegram bot.&lt;/p&gt;
&lt;p&gt;Many years ago, when Telegram&amp;rsquo;s bot API was still young, I tried to create a bot that would send you random pictures of aurorae if you asked. That bot and the server that it lived on crashed a long time ago. But the bot&amp;rsquo;s name and API key lived on, still registered with Telegram&amp;rsquo;s servers. I decided to necromance this bot from the dead and inject it with some fun new functionality. Being a lover space exploration and what it represents for humanity, I had the idea of giving the bot the ability to send you random images from NASA with informative descriptions as seen on the 
&lt;a href=&#34;https://images.nasa.gov/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;NASA Image and Video Library&lt;/a&gt;.&lt;/p&gt;
&lt;h2 id=&#34;using-the-nasa-images-api&#34;&gt;Using the NASA Images API&lt;/h2&gt;
&lt;p&gt;The first problem to solve is getting a random image from the NASA Image and Video Library. At first, I thought that I&amp;rsquo;d have to use a web-scraping python library to extract the images. But things turned out to be much easier. NASA has quite a few APIs that they&amp;rsquo;ve listed on 
&lt;a href=&#34;https://api.nasa.gov/api.html#MarsPhotos&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;this page&lt;/a&gt;. Using their API, I can search through the images for any query I like and retrieve results in the form of JSON formatted data. The API uses &lt;code&gt;HTTP GET&lt;/code&gt; requests (
&lt;a href=&#34;https://www.w3schools.com/tags/ref_httpmethods.asp&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;more info here&lt;/a&gt;). So for example, if I need to search for images related to planets using the API, I would open the URL: 
&lt;a href=&#34;https://images-api.nasa.gov/search?q=planet&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;https://images-api.nasa.gov/search?q=planet&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;There&amp;rsquo;s one extra step here. If you click on the api link above and examine the results, you&amp;rsquo;ll notice that it does not return all the results of a search at once. Instead, it gives you the first 100 results and gives you the option of getting more using the &amp;lsquo;page&amp;rsquo; parameter in the web request. So if I want to access the results from the 5th page of a search, I&amp;rsquo;d use the URL: 
&lt;a href=&#34;https://images-api.nasa.gov/search?q=planet&amp;amp;page=5&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;https://images-api.nasa.gov/search?q=planet&amp;amp;page=5&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;So, to select a random result, I need to select a number between 1 and the total number of results and use modular arithmetic to figure out which page to get the result from. I encapsulated this logic in a single function that returns the URL and caption of a random result given a search query.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-py&#34;&gt;import urllib.parse
import urllib.request
import json
import random
import math
import traceback

def get_random_nasa_image(search_term=&#39;planet&#39;):
    &amp;quot;&amp;quot;&amp;quot;
    Fetch a random image from the NASA media library.
    &amp;quot;&amp;quot;&amp;quot;
    try:
        # The API URL
        nasa_img_url = &amp;quot;https://images-api.nasa.gov/search&amp;quot;
        # Setup the search data
        send_data = {}
        send_data[&#39;q&#39;] = search_term
        send_data[&#39;media_type&#39;] = &#39;image&#39;
        # Encode the url
        url_values = urllib.parse.urlencode(send_data)
        url = nasa_img_url + &#39;?&#39; + url_values
        data = urllib.request.urlopen(url)
        json_data = json.loads(data.read().decode(&#39;utf-8&#39;))
        
        num_results = json_data[&#39;collection&#39;][&#39;metadata&#39;][&#39;total_hits&#39;]
        result_to_use = random.choice([i for i in range(num_results)])
        page_num = math.ceil(result_to_use/100.0)
        result_num_in_page = result_to_use%100
        
        if page_num != 1:
            # Do another request
            send_data[&#39;page&#39;] = page_num
            url_values = urllib.parse.urlencode(send_data)
            url = nasa_img_url + &#39;?&#39; + url_values
            data = urllib.request.urlopen(url)
            json_data = json.loads(data.read().decode(&#39;utf-8&#39;))
            image_url = json_data[&#39;collection&#39;][&#39;items&#39;][result_num_in_page][&#39;links&#39;][0][&#39;href&#39;]
            image_caption = json_data[&#39;collection&#39;][&#39;items&#39;][result_num_in_page][&#39;data&#39;][0][&#39;description&#39;]
            image_title = json_data[&#39;collection&#39;][&#39;items&#39;][result_num_in_page][&#39;data&#39;][0][&#39;title&#39;]
        else:
            image_url = json_data[&#39;collection&#39;][&#39;items&#39;][result_num_in_page][&#39;links&#39;][0][&#39;href&#39;]
            image_caption = json_data[&#39;collection&#39;][&#39;items&#39;][result_num_in_page][&#39;data&#39;][0][&#39;title&#39;]
            image_title = json_data[&#39;collection&#39;][&#39;items&#39;][result_num_in_page][&#39;data&#39;][0][&#39;description&#39;]

        return (image_url, image_title, image_caption)
    except Exception as e:
        traceback.print_exc()
        err_url = &#39;https://upload.wikimedia.org/wikipedia/commons/3/3b/Gato_enervado_pola_presencia_dun_can.jpg&#39;
        err_caption = &#39;Uh-Oh. Something went wrong. Here\&#39;s a picture of a cat instead.&#39;
        return (err_url, err_caption, json_data)
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;sending-the-image-to-telegram&#34;&gt;Sending the Image to Telegram&lt;/h2&gt;
&lt;p&gt;To make a Telegram Bot send an image to a user we need three pieces of information.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;em&gt;The Chat ID&lt;/em&gt; : The chat ID is like a serial number that uniquely identifies the chat between a bot and a user.&lt;/li&gt;
&lt;li&gt;&lt;em&gt;The Photo&lt;/em&gt; : There are a few different formats that telegram accepts the photo in. I chose the simplest option, a string with the URL to the photo.&lt;/li&gt;
&lt;li&gt;&lt;em&gt;The Bot API Key&lt;/em&gt; : This is a long random looking string that you get when you create a bot. See instructions 
&lt;a href=&#34;https://core.telegram.org/bots#botfather&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;here&lt;/a&gt; to learn how to get your own.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;The actual sending of the message is achieved by using more HTTP GET or POST requests. In this case I used the 
&lt;a href=&#34;https://core.telegram.org/bots/api#sendphoto&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;sendPhoto&lt;/a&gt; function defined in the API. Again, I encapsulated the functionality to send the photo into a single function.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-py&#34;&gt;def sendPhoto(chat_id, url, caption):
    sendPhotoUrl = &#39;https://api.telegram.org/bot{your-api-key}/sendPhoto&#39;
    data = {}
    data[&#39;chat_id&#39;] = chat_id
    data[&#39;photo&#39;] = url
    data[&#39;caption&#39;] = caption
    data = urllib.parse.urlencode(data)
    data = data.encode(&#39;ascii&#39;) # data should be bytes
    
    req = urllib.request.Request(sendPhotoUrl, data)
    
    with urllib.request.urlopen(req, timeout=10) as response:
        the_page = response.read()
        
    return the_page
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;setting-up-a-google-cloud-function&#34;&gt;Setting Up a Google Cloud Function&lt;/h2&gt;
&lt;p&gt;Google Cloud Functions allow you to execute a custom block of code when triggered by some kind of event - like it being a certain time of the day. Apart from Google, companies like Amazon and Microsoft also have their own versions of cloud functions.&lt;/p&gt;
&lt;p&gt;Since my application logic was fairly simple, I opted to setup my cloud function from their web interface by following the instructions on this 
&lt;a href=&#34;https://cloud.google.com/functions/docs/quickstart-console&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;page&lt;/a&gt;. I kept all the default settings and opted to use Python 3.7 since that&amp;rsquo;s the programming language that I&amp;rsquo;m the most familiar with. The &amp;lsquo;hello_world&amp;rsquo; function that they have setup is the function that will be called when the service is triggered.&lt;/p&gt;
&lt;p&gt;Inside the function, I need to implement some very simple logic:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Extract the Chat ID from the incoming message.&lt;/li&gt;
&lt;li&gt;Get a random NASA photo.&lt;/li&gt;
&lt;li&gt;Send the photo (along with its caption) to the incoming message&amp;rsquo;s Chat ID&lt;/li&gt;
&lt;li&gt;Return an HTTP OK response.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Here&amp;rsquo;s my code for the main function that&amp;rsquo;s called when an event is triggered. I&amp;rsquo;ve added some exception handling to the main logic as well.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-py&#34;&gt;def hello_world(request):
    &amp;quot;&amp;quot;&amp;quot;Responds to any HTTP request.
    Args:
        request (flask.Request): HTTP request object.
    Returns:
        The response text or any set of values that can be turned into a
        Response object using
        `make_response &amp;lt;http://flask.pocoo.org/docs/1.0/api/#flask.Flask.make_response&amp;gt;`.
    &amp;quot;&amp;quot;&amp;quot;
    request_json = request.get_json()
    
    doneFlag = False
    try_counter = 0
    try_max = 5
    
    while not doneFlag:
        try:
            # Send back a random nasa photo
            photo, title, caption = get_random_nasa_image()
            print(photo)
            sendPhoto(request_json[&#39;message&#39;][&#39;chat&#39;][&#39;id&#39;],
                      photo, caption)
            doneFlag = True
        except:
            print(&amp;quot;Something Went Wrong. Trying again!&amp;quot;)
            try_counter = try_counter + 1
            if try_counter &amp;gt; 5:
                doneFlag = True
                traceback.print_exc()
                sendPhoto(request_json[&#39;message&#39;][&#39;chat&#39;][&#39;id&#39;],
                          &#39;https://upload.wikimedia.org/wikipedia/commons/3/3b/Gato_enervado_pola_presencia_dun_can.jpg&#39;,
                          &#39;I\&#39;m Sorry, something went wrong. Here\&#39;s a cat picture instead. :P&#39;)
            else:
                pass

    
    print(request_json)
    return f&#39;HTTP/1.0 200 OK&#39;
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;connecting-the-telegram-bot-to-the-cloud-function&#34;&gt;Connecting the Telegram Bot to the Cloud Function.&lt;/h2&gt;
&lt;p&gt;The final step is to connect the Telegram Bot to the Cloud Function so that the function is triggered every time the bot receives a message from someone. The Telegram API has a function for just that. 
&lt;a href=&#34;https://core.telegram.org/bots/api#setwebhook&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;setWebhook&lt;/a&gt; allows you to set a URL that gets called every time the bot gets a new message. All the message data is passed on in JSON format. To connect your bot to the cloud function that you just created, you need to set the webhook to the URL specified in the &amp;lsquo;Trigger&amp;rsquo; tab of the function details page.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;https://www.ashwinnarayan.com/img/gcf_trigger.JPG&#34; alt=&#34;gcf_image&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;demo&#34;&gt;Demo&lt;/h2&gt;
&lt;p&gt;And we&amp;rsquo;re done! If there are no errors in the code, your bot should be triggered every time it receives a message. Here&amp;rsquo;s a demo of my bot working:&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;https://www.ashwinnarayan.com/img/telegram_bot_demo.png&#34; alt=&#34;demo_image&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;conclusion&#34;&gt;Conclusion&lt;/h2&gt;
&lt;p&gt;Successes like these are the reason that I sometimes revive old projects. In the years that passed between my two attempts, some technologies had become cheap enough that I could use it nearly for free. In my last attempt to build the bot, I used a custom VPS server (basically a linux server) to try and run the bot. This meant that in addition to the logic for the bot, I needed to figure out how to get the bot to run on the server reliably. I often had to go back and restart the server or the script because it had got itself into an unexpected state. For cloud functions, there is no state. Each event invokes a new call of the function and if there is an error, the next function call isn&amp;rsquo;t affected by it. I also don&amp;rsquo;t need to worry about reliability and uptime because Google manages the service. Building systems like these are a great way of learning more about the inner workings of the internet and I hope that others who want to build their own Telegram bots (or other web based things) can use this article as a starting point.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Cartpole Dynamics and Control</title>
      <link>https://www.ashwinnarayan.com/post/cartpole-dynamics/</link>
      <pubDate>Sun, 21 Apr 2019 08:56:44 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/cartpole-dynamics/</guid>
      <description>&lt;h2 id=&#34;introduction&#34;&gt;Introduction&lt;/h2&gt;
&lt;p&gt;As is the case for a lot of PhDs, my main work focuses on a small part of robotics. There are many areas of robotics that I would love to work on but do not. As part of my ongoing effort to learn more about these areas, I work on accessible problems that interest me. One area of robotics that fascinates me is that of rigid body dynamics and control. Regardless of how many times I see it, there is something magical about using mathematics to make correct predictions about the world. Newtonian mechanics - the science that powers most modern robots - is many hundreds of years old, but I can still feel the magic when the equations come to life.&lt;/p&gt;
&lt;p&gt;One toy system that is commonly used to learn about dynamics and control theory is the 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Inverted_pendulum&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;cart-pole or inverted pendulum&lt;/a&gt;. Over the past few weeks, I&amp;rsquo;ve been working through simulating the dynamics of the system. I alse tried out some common control strategies to perform the task of balancing the pendulum with its center of mass above the joint. In this article I&amp;rsquo;ll go through the process from beginning to end. I think the cart pole system is very convenient as it is simple enough that its dynamics can be worked out by hand. Concomitantly, it is complex enough to warrant applying some advanced control strategies.&lt;/p&gt;
&lt;h2 id=&#34;modeling-and-simulating-the-cart-pole-system&#34;&gt;Modeling and Simulating the Cart-Pole System&lt;/h2&gt;
&lt;p&gt;&lt;img src=&#34;https://www.ashwinnarayan.com/img/cart-pole.png&#34; alt=&#34;cart_pole_image&#34;&gt;&lt;/p&gt;
&lt;p&gt;The diagram above (lifted from the Wikipedia article) shows what the system looks like. It is assumed that the cart is on a fixed linear rail (frictionless of course). This can be considered a prismatic joint in robotics terminology. The pendulum is mounted on the cart with a revolute joint that has a single rotational degree of freedom. There are a few ways to model the pendulum. Some model it as a uniform bar/cylinder and some as a concentrated mass at the end of a massless link. For the purposes of this article, I&amp;rsquo;ll be modeling it as a thin cylindrical rod.&lt;/p&gt;
&lt;h3 id=&#34;lagrangian-mechanics&#34;&gt;Lagrangian Mechanics&lt;/h3&gt;
&lt;p&gt;
&lt;a href=&#34;https://en.wikipedia.org/wiki/Lagrangian_mechanics&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Lagrangian mechanics&lt;/a&gt; is a fascinating and beautiful formulation of classical mechanics. Rather than the three laws of motion, Lagrangian mechanics is interested in a scalar quantity called the &lt;em&gt;action&lt;/em&gt; which is a function of the state of the mechanical system. By applying a simple constraint known as the 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Principle_of_least_action&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Principle of Least Action&lt;/a&gt;, you can get the equations of motion for any system in any coordinate system.&lt;/p&gt;
&lt;p&gt;To apply Lagrangian Mechanics to the cart-pole system, I need to first write down the Lagrangian of the system which is defined as the difference between the potential and kinetic energies of the system as functions of the state.&lt;/p&gt;
&lt;p&gt;Since the cart moves perpedicular to gravity, the potential energy $V$ only depends on the vertical position of the pendulum.&lt;/p&gt;
&lt;p&gt;$$ V = -m_{p}gl\cos{\theta} $$&lt;/p&gt;
&lt;p&gt;The Kinetic Energy of the system is a bit more involved. It&amp;rsquo;s the sum of the kinetic energies of the cart and the pole.&lt;/p&gt;
&lt;p&gt;$$ \begin{align} T &amp;amp;= \frac{1}{2} m_c \dot{x}^2 + \frac{1}{2}m_p \left[ (\dot{x} + l\dot{\theta}\cos{\theta})^2 + (l\dot{\theta} \sin{\theta})^2\right]  \\
&amp;amp;= \frac{1}{2} (m_c + m_p) \dot{x}^2 + \frac{1}{2} m_p l^2 \dot{\theta}^2 (\cos^2{\theta} + \sin^2{\theta}) + m_p l \dot{x}\dot{\theta}\cos{\theta} \\
&amp;amp;= \frac{1}{2} (m_c + m_p) \dot{x}^2 + \frac{1}{2} m_p l^2 \dot{\theta}^2 + m_p l \dot{x}\dot{\theta}\cos{\theta}\end{align} $$&lt;/p&gt;
&lt;p&gt;The Lagrangian is then:&lt;/p&gt;
&lt;p&gt;$$ \mathcal{L} = T - V $$&lt;/p&gt;
&lt;p&gt;In Lagrangian mechanics, as the system evolves over time, a quantity called &lt;em&gt;action&lt;/em&gt; is defined as the integral of the Lagrangian.&lt;/p&gt;
&lt;p&gt;$$ S = \int_{t_1}^{t_2} \mathcal{L} dt$$&lt;/p&gt;
&lt;p&gt;According to the Principle of Least Action, the dynamics of the system evolves so that this quantity - the action - is minimized. Once I have the action I can use the 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Euler%E2%80%93Lagrange_equation&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Euler-Lagrange equations&lt;/a&gt; to find the equations of motion of the system.&lt;/p&gt;
&lt;p&gt;$$ \frac{d}{dt} \frac{\partial \mathcal{L}}{\partial \dot{q}_i} - \frac{\partial \mathcal{L}}{\partial q_i} = F_i$$&lt;/p&gt;
&lt;p&gt;The $q_i$ represent the state variables of the system and $F_i$ generalized forces. By applying these equations once for each state variable I get the full equations of motion of the system. In the case of the cart pole system, the state variables are the position of the cart and the angle between the cart and the pendulum. The resulting two equations are:&lt;/p&gt;
&lt;p&gt;$$ \begin{align} -m_p l \dot{\theta} \sin{\theta} + (m_c + m_p) \ddot{x} + m_p l \ddot{\theta} \cos{\theta} = F_1 \\
m_p g l \sin{\theta} + m_p l \ddot{x} \cos{\theta} + m_p l^2 \ddot{\theta} = F_2 \end{align} $$&lt;/p&gt;
&lt;p&gt;The central equation of study in robot dynamics are the manipulator equations. These equations are a general way to express the dynamics of a multi-link rigid body. By inspecting the equations of motion derived above, they can be expressed in the manipulator equation form:&lt;/p&gt;
&lt;p&gt;$$ H(q)\ddot{q} + C(q, \dot{q})\dot{q} + G(q) = F $$&lt;/p&gt;
&lt;p&gt;Where&lt;/p&gt;
&lt;p&gt;$$ H = \begin{bmatrix} m_c + m_p &amp;amp; m_p l \cos{\theta} \\
m_p l \cos{\theta} &amp;amp; m_p l^2 \end{bmatrix}$$
$$ C = \begin{bmatrix} 0 &amp;amp; -m_p l \dot{\theta} \sin{\theta} \\
0 &amp;amp; 0 \end{bmatrix} $$
$$ G = \begin{bmatrix} 0 \\
m_p g l \sin{\theta} \end{bmatrix} $$
$$ q = \begin{bmatrix} x \\
\theta \end{bmatrix} $$&lt;/p&gt;
&lt;h3 id=&#34;simulating-the-cart-pole-system&#34;&gt;Simulating the Cart Pole System&lt;/h3&gt;
&lt;p&gt;There are a few ways to simulate a mechanical system once you have the equations of motion. Python is an excellent option. The 
&lt;a href=&#34;https://www.scipy.org/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;scipy&lt;/a&gt; package has a good set of numerical integrators. You just have to feed in the initial conditions of the system and it&amp;rsquo;ll simulate the system for as long as you want (at least, until your RAM runs out). However, for this project, I chose to use MATLAB. Mathworks decided to make the student (and personal) version of MATLAB available for ridiculously cheap prices (compared to their organizational licenses). So about a year ago I bought their student license so I could learn to use it. Everything I do in this article can be done just as well using Python and scipy. However, I do admit that using MATLAB makes the work a little smoother.&lt;/p&gt;
&lt;p&gt;For simulating the cart-pole I will be using the Simscape Multibody toolbox for Simulink.
&lt;img src=&#34;https://www.ashwinnarayan.com/img/cartpole_simscape.png&#34; alt=&#34;cart_pole_simscape&#34;&gt;&lt;/p&gt;
&lt;p&gt;Without any kind of control system active, we can see the dynamics of the free system quite nicely.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;https://www.ashwinnarayan.com/img/cartpole_uncontrolled.gif&#34; alt=&#34;cart_pole_uncontrolled&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;balancing-control&#34;&gt;Balancing Control&lt;/h2&gt;
&lt;p&gt;The balancing control task is that of having the pendulum balance with its center of mass above the cart by only moving the cart (there is no actuator on the revolute joint). The control input in this task is a force that is applied to the cart (through electric motors or rocket engines or some other means of actuation).&lt;/p&gt;
&lt;p&gt;The cart pole system is a highly non-linear system. However, just like how the motion of the simple pendulum can be approximated by a linear system for small angles, the cart pole system can be linearized too. Sometimes in engineering, the approach of &amp;ldquo;fiddling with it till it works&amp;rdquo; really works! So the first thing I tried to do is to implement a simple PD controller. If the system is linear around the balancing point (which it is in this case) and long as the states aren&amp;rsquo;t too far off, this approach will work.&lt;/p&gt;
&lt;h3 id=&#34;hand-tuned-control-gains&#34;&gt;Hand-Tuned Control Gains&lt;/h3&gt;
&lt;p&gt;So the very first thing I tried are hand tuned control gains. I just assumed that I could achieve what I wanted by using the control signal $u = K\cdot s$ where $s$ is the state vector with the positions and velocities: $s = \begin{bmatrix} x &amp;amp; \dot{x} &amp;amp; \theta &amp;amp; \dot{\theta}\end{bmatrix}^T$. After a bit (a lot) of fiddling, I did manage to find a set of control gains that worked. Here&amp;rsquo;s what the controller looks like when it tries to balance the pendulum.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;https://www.ashwinnarayan.com/img/handtuned_pd.gif&#34; alt=&#34;handtuned_pd&#34;&gt;&lt;/p&gt;
&lt;h3 id=&#34;lqr&#34;&gt;LQR&lt;/h3&gt;
&lt;p&gt;To avoid wasting all that time fiddling, control engineers invented a type of controller called a Linear Quadratic Regulator. LQR controllers formalize the process of fiddling by defining a cost function on the states and control inputs. The optimal control gain vector $K$ is the vector that minimizes this cost function. LQR is fundamental enough in control theory that standard functions exist to calculate the control gains if you have the linearized system. Such functions exist in both 
&lt;a href=&#34;https://www.mathworks.com/help/control/ref/lqr.html&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;MATLAB&lt;/a&gt; and 
&lt;a href=&#34;https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.solve_continuous_are.html&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;scipy&lt;/a&gt; or 
&lt;a href=&#34;https://python-control.readthedocs.io/en/0.8.2/generated/control.lqr.html&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;specialized control libraries&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;To do LQR, we first need to linearize the system around an &amp;ldquo;operating point&amp;rdquo;. This process can be little (but not too much) involved if you try to do it by hand so I applied liberal amounts Mathematica to help me out (you can do the same using 
&lt;a href=&#34;https://www.sympy.org/en/index.html&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;SymPy&lt;/a&gt; in Python). I first expressed the equations of motion in the form $\dot{s} = f(s, u)$. This can be done by rearranging the manipulator equations. Once you have the dynamics in this form, the linearized equations of motion can be expressed as:&lt;/p&gt;
&lt;p&gt;$$ \dot{x} = A(s - s^*) + B(u - u^{ *}) $$&lt;/p&gt;
&lt;p&gt;Where&lt;/p&gt;
&lt;p&gt;$$ A = \frac{\partial f}{\partial s}\Bigr\rvert _{s=s^{*}} $$
$$ B = \frac{\partial f}{\partial u}\Bigr\rvert _{u=u^{ *}} $$&lt;/p&gt;
&lt;p&gt;For the cart pole system, the matrices come out as:&lt;/p&gt;
&lt;p&gt;$$ A = \begin{bmatrix} 0 &amp;amp; 0 &amp;amp; 1 &amp;amp; 0 \\
0 &amp;amp; 0 &amp;amp; 0 &amp;amp; 1 \\
0 &amp;amp; \frac{m_p g}{m_c} &amp;amp; 0 &amp;amp; 0 \\
0 &amp;amp; \frac{(m_c + m_p)g}{m_c l} &amp;amp; 0 &amp;amp; 0 \end{bmatrix} $$&lt;/p&gt;
&lt;p&gt;$$ B = \begin{bmatrix} 0 \\  0 \\  \frac{1}{m_c} \\  \frac{1}{m_c l}\end{bmatrix} $$&lt;/p&gt;
&lt;p&gt;To compute the optimal LQR control gains, I need to define a few more matrices. As I said before, LQR finds the gain matrix $K$ that optimizes the cost function&lt;/p&gt;
&lt;p&gt;$$ J = \int_0^{\infty} (s^TQs + u^TRu + 2x^TNu) dt$$&lt;/p&gt;
&lt;p&gt;I need to define the matrix $Q$, $R$ and $N$. You can think of $Q$ as a matrix of weights that tell you how much to &amp;ldquo;penalize&amp;rdquo; certain combinations of the state. For instance the first term in the diagonal of the $Q$ matrix tells you how much to penalize the value of the state variable $x$. The same goes for other matrices. Having the $Q$ matrix as a scalar multiple of the identity matrix is a good default. $R$ is just a single scalar value. $N$ can be skipped in most cases. With these I got a control gain matrix that also successfully drove the states to my target. It looked quite similar to my hand tuned control gains actually. On close inspection you can see that the system does reach it&amp;rsquo;s target slightly faster.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;https://www.ashwinnarayan.com/img/cartpole_LQR_control.gif&#34; alt=&#34;cartpole_lqr_control&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;conclusion&#34;&gt;Conclusion&lt;/h2&gt;
&lt;p&gt;Dynamics is an important part of a roboticist&amp;rsquo;s toolkit. Learning dynamics from a textbook can be a bit daunting. For me, implementing the ideas in code and generating nice animations helps me to get a better intuition of the mathematics. Now that I have the environment set up, I&amp;rsquo;m considering trying my hand at some swing-up control using energy shaping methods or reinforcement learning.&lt;/p&gt;
&lt;h2 id=&#34;references&#34;&gt;References&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;a href=&#34;https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-832-underactuated-robotics-spring-2009/readings/MIT6_832s09_read_ch03.pdf&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Acrobot and Cartpole, Russ Tedrake 2009&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://www.mathworks.com/help/control/ref/lqr.html&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;MATLAB&amp;rsquo;s LQR Design Function&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://en.wikipedia.org/wiki/Euler%E2%80%93Lagrange_equation&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Euler-Lagrange Equation&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;
</description>
    </item>
    
    <item>
      <title>Learning Haskell Through Google Code Jam</title>
      <link>https://www.ashwinnarayan.com/post/learning-haskell-google-code-jam/</link>
      <pubDate>Sat, 13 Apr 2019 08:26:34 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/learning-haskell-google-code-jam/</guid>
      <description>&lt;h2 id=&#34;introduction&#34;&gt;Introduction&lt;/h2&gt;
&lt;p&gt;Over the last year or so, I&amp;rsquo;ve been playing around with 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Functional_programming&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;functional programming&lt;/a&gt;. As the first few lines of the Wikipedia page suggest, functional programming is all about expressing a computation or algorithm as the composition of functions rather than using a state that changes over time. From what I&amp;rsquo;ve understood so far, functional programming is based on 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Lambda_calculus&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;lambda calculus&lt;/a&gt; which is an alternative but equivalent formulation of the famous Turing Machine that most modern computers are based on.&lt;/p&gt;
&lt;p&gt;Once you start reading up on functional programming, the language that is most often recommended is 
&lt;a href=&#34;https://www.haskell.org/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Haskell&lt;/a&gt;. I got interested in functional programming and Haskell in the first place because I was attracted by its more mathematical appearance. A lot of the code that I looked at seemed to express ideas much more clearly and (in my opinion) more beautifully. However, Learning Haskell was not easy at all. As someone who&amp;rsquo;s been programming using imperative languages all my life, I found it unusually difficult to think about solving problems using the style that Haskell (and functional programming) imposed. Near the beginning of my journey to learn the language, there were quite a lot of stops and restarts and many instances where I questioned whether it was even useful to learn the language. I found it so difficult to express ideas that were, in my head simple to express in a language like Python. I also found writing programs that required I/O quite difficult. However, the aforementioned clarity and beauty that I found in the way functional programming expressed ideas stuck with me and I kept coming back to it. after nearly a year, things fell into place and I started writing code that was actually useful (i.e. interacted with the world through I/O). I feel like I&amp;rsquo;m finally at a point where I can program well enough in the language that I can solve problems without struggling too much with I/O. So, when I got the email notifying me about this year&amp;rsquo;s Google Code Jam I thought I&amp;rsquo;d participate and try to use Haskell as much as possible!&lt;/p&gt;
&lt;h2 id=&#34;google-code-jam&#34;&gt;Google Code Jam&lt;/h2&gt;
&lt;p&gt;I&amp;rsquo;ve known about Google Code Jam for quite a while. I&amp;rsquo;ve even tried participating once before near the beginning of my undergraduate degree. Being a novice at the time, I did not even make it past the qualifying round. Since then I&amp;rsquo;ve been programming on a regular basis for nearly six years and it&amp;rsquo;s paid off. This time, I made it past the qualifying round quite comfortably. The main challenge before me was my use of a programming language that I hadn&amp;rsquo;t fully mastered yet. The added challlenge did make solving the problems a lot more fun however. Along the way, I was able to take advantage of some functional programming patterns and I thought that it might be valuable to write an article about how these patterns can be useful.&lt;/p&gt;
&lt;h2 id=&#34;problem-1---foregone-solution&#34;&gt;Problem 1 - Foregone Solution&lt;/h2&gt;
&lt;p&gt;To read the full problem description 
&lt;a href=&#34;https://codingcompetitions.withgoogle.com/codejam/round/0000000000051705/0000000000088231&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;go here&lt;/a&gt;.&lt;/p&gt;
&lt;h3 id=&#34;summary-of-problem-statement&#34;&gt;Summary of Problem Statement&lt;/h3&gt;
&lt;p&gt;The input for each testcase is a number N which when expressed in base 10 may or may not contain the digit 4. The goal is to split up the number N into 2 numbers A and B so that A + B = N and neither A nor B contain the digit 4.&lt;/p&gt;
&lt;h3 id=&#34;analysis&#34;&gt;Analysis&lt;/h3&gt;
&lt;p&gt;A brute force approach to the solution would search through all possible sums of two integers between 0 and N/2. Of course, this solution would scale as $O(N^2)$ and would not work with the larger test cases. Another thing to think about is that the hidden test cases can contain numbers between 1 and $10^{100}$. That number is beyond the range of usual integer data types. The problem can be solved quite easily by making the simple observation that you can split up all the digits that are 4 into 2 and 2 (or 3 and 1) and easily generate two numbers without even adding the two numbers to check if they sum up to N. For instance, if N is 9454 you can split it up into 9252 and 202. To do this you do not even need to convert the number into an integer data type. You can work with the string representation directly.&lt;/p&gt;
&lt;h3 id=&#34;solution&#34;&gt;Solution&lt;/h3&gt;
&lt;p&gt;I will read each test case number as a string and create two new numbers A and B. A will have all the digits 4 replaced with 2 and the remaining digits the same. B Will have all the digits 4 replaced with 2 and all the remaining digits replaced with 0. This pattern of replacing each member of an array with another one using information from only a single array element can be implemented using the higher order function &lt;code&gt;map&lt;/code&gt;. So, I defined two functions to calculate A and B.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-hs&#34;&gt;getA :: [Char] -&amp;gt; [Char]
getA n = map (\x -&amp;gt; if x == &#39;4&#39; then &#39;2&#39; else &#39;0&#39;) n

getB :: [Char] -&amp;gt; [Char]
getB n = map (\x -&amp;gt; if x == &#39;4&#39; then &#39;2&#39; else x) n
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The rest of the solution is just I/O. You can see my full solution 
&lt;a href=&#34;https://gist.github.com/RationalAsh/b92dfab3970e5d9ba2b4855afedf0d5c&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;here&lt;/a&gt;.&lt;/p&gt;
&lt;h2 id=&#34;problem-2-you-can-go-your-own-way&#34;&gt;Problem 2: You Can Go Your Own Way&lt;/h2&gt;
&lt;p&gt;To read the full problem description 
&lt;a href=&#34;https://codingcompetitions.withgoogle.com/codejam/round/0000000000051705/00000000000881da&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;go here&lt;/a&gt;.&lt;/p&gt;
&lt;h3 id=&#34;summary-of-the-problem-statement&#34;&gt;Summary of the Problem Statement&lt;/h3&gt;
&lt;p&gt;The goal is to get from the top right corner of an NxN grid to the bottom right corner using only South (Down) and East (Right) moves with the additional constraint that any segment of the path taken must not coincide (but can intersect at a single point) with another path that someone called Lydia took. The input is this path which is represented as a string containing uppercase &amp;ldquo;S&amp;rdquo; and &amp;ldquo;E&amp;rdquo; characters only.&lt;/p&gt;
&lt;h3 id=&#34;analysis-1&#34;&gt;Analysis&lt;/h3&gt;
&lt;p&gt;This problem looks more difficult to solve than it actually is. Once you know the trick, the code is quite simple. Here are some observations about the problem which helped me arrive at the solution.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Observation 1: Number of &lt;code&gt;S&lt;/code&gt; moves and &lt;code&gt;E&lt;/code&gt; moves must be exactly equal to &lt;code&gt;N-1&lt;/code&gt; if you want to reach the bottom right corner. You can see this by thinking of each move as a vector. This implies that it might be possible to find the solution by just transforming the input string as it is read.&lt;/li&gt;
&lt;li&gt;Observation 2: If I have a function that only stays the same or decreases along the X-axis and intersects the point (0, 0), I can mirror the function along the line y=-x and the only places where the path intersects will be crossings. That means I can solve this by just doing the opposite of whatever Lydia does at each step.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;This means that I can take Lydia&amp;rsquo;s path and reverse the action she took at each step like some dark mirror and I have my solution. Interestingly, this problem can also be solved using the &amp;ldquo;map&amp;rdquo; higher order function pattern in Haskell. The meat of my solution was implemented in two functions. One is the character (move) mapping function:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-hs&#34;&gt;flipMove :: Char -&amp;gt; Char
flipMove c
    | c == &#39;S&#39; = &#39;E&#39;
    | c == &#39;E&#39; = &#39;S&#39;
    | otherwise = c
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;And another is the function that transforms the input string into the output string.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-hs&#34;&gt;solveCase :: String -&amp;gt; String
solveCase lydiasMoves = map flipMove lydiasMoves
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;As before, the rest of the code is just IO. My full solution is 
&lt;a href=&#34;https://gist.github.com/RationalAsh/ba917a855dc63400245478ad4a03b1e5&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;here&lt;/a&gt;.&lt;/p&gt;
&lt;h2 id=&#34;problem-3-cryptopangrams&#34;&gt;Problem 3: Cryptopangrams&lt;/h2&gt;
&lt;p&gt;This problem was a bit harder than the others. I spent a lot of time thinking about this one and solved it quite close to the end of the round. Some of my initial attempts failed because I didn&amp;rsquo;t consider all the edge cases. Read the full problem statement 
&lt;a href=&#34;https://codingcompetitions.withgoogle.com/codejam/round/0000000000051705/000000000008830b&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;here&lt;/a&gt;.&lt;/p&gt;
&lt;h3 id=&#34;summary-of-problem-statement-1&#34;&gt;Summary of Problem Statement&lt;/h3&gt;
&lt;p&gt;A string is &amp;ldquo;encoded&amp;rdquo; using the following procedure:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;26 prime numbers less than a number N are chosen.&lt;/li&gt;
&lt;li&gt;The numbers are sorted in increasing order and a character map is made from the numbers to the corresponding letter between A and Z.&lt;/li&gt;
&lt;li&gt;Each character in the sentence is replaced with the corresponding prime number (spaces are removed and ignored).&lt;/li&gt;
&lt;li&gt;The prime number at each position is replaced with the product of the number and the number corresponding to the next character in the sentence.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;As an additional condition, the string is guaranteed to have all 26 characters occur at least once.&lt;/p&gt;
&lt;p&gt;For each case, as input, the maximum number N and the encoded sentence is given. The output should be the decoded sentence (without spaces).&lt;/p&gt;
&lt;h3 id=&#34;analysis-2&#34;&gt;Analysis&lt;/h3&gt;
&lt;p&gt;Let each sentence that is encoded be made of L characters. The set of primes that represent each of these characters can be represented by the sequence of numbers: $\{P_1, P_2, &amp;hellip; , P_L\}$. After the &amp;ldquo;encoding&amp;rdquo; procedure is carried out, the sequence will look like: $\{P_1\times P_2, P_2\times P_3, &amp;hellip; , P_{L-1}\times P_{L}\}$. The brute-force approach to solve this problem would involve trying to find the prime factors of each number in the sequence. However, if you look at the sequence above you can see that each number in the sequence except for the first one shares a common factor with the number before it! This means that if I find the common factors of the first two numbers in the sequence then I can factorize the entire sequence quite easily using the following procedure:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Find the common factor between the first two numbers in the sequence.&lt;/li&gt;
&lt;li&gt;Divide the first number by this common factor to get the first factor.&lt;/li&gt;
&lt;li&gt;Second factor is the common factor.&lt;/li&gt;
&lt;li&gt;For all subsequent numbers, the first factor is the common factor with the previous number and the second factor is the number divided by the common factor.&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id=&#34;solution-1&#34;&gt;Solution&lt;/h3&gt;
&lt;p&gt;So first, I wrote a function to find the greatest common divisor between two numbers. This function implements 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Euclidean_algorithm&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Euclid&amp;rsquo;s Algorithm&lt;/a&gt; for find the greatest common divisor of two numbers:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-hs&#34;&gt;commonFactor :: Integer -&amp;gt; Integer -&amp;gt; Integer
commonFactor a b
    | remainder == 1 = 1
    | remainder == 0 = if a &amp;gt; b then b else a
    | otherwise = if a &amp;gt; b then commonFactor b remainder else commonFactor a remainder 
    where remainder = if a &amp;gt; b then snd (quotRem a b) else snd (quotRem b a)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;In an imperative programming language we would loop through each character in the sequence to find the factors after setting up the loop by finding the common factor between the first two numbers. In Haskell the loop pattern for solving this particular problem is captured quite beautifully using the higher order function &lt;code&gt;scanl&lt;/code&gt;. The type signature for &lt;code&gt;scanl&lt;/code&gt; is &lt;code&gt;(b -&amp;gt; a -&amp;gt; b) -&amp;gt; b -&amp;gt; [a] -&amp;gt; [b]&lt;/code&gt;. This means that scanl takes a function that takes a type &lt;code&gt;a&lt;/code&gt; and &lt;code&gt;b&lt;/code&gt; and returns a &lt;code&gt;b&lt;/code&gt;, a member of type &lt;code&gt;b&lt;/code&gt; and a list of type &lt;code&gt;a&lt;/code&gt; and returns a list of type &lt;code&gt;b&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;A &lt;code&gt;scanl&lt;/code&gt; is a higher order function that is a variant of a general pattern in computing called a &lt;code&gt;fold&lt;/code&gt;. To put it very simply, a fold takes a starting value (sometimes called a &lt;em&gt;seed&lt;/em&gt;), a function and a list and applies the function repeatedly in a specific way. If I write down the fold imperatively in a language like Python, it would look like this (f is the function that is applied recursively):&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-python&#34;&gt;seed = 0
for idx, elem in enumerate(lst):
    if idx == 0:
        result = f(seed, elem)
    else:
        result = f(result, elem)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;A &lt;code&gt;fold&lt;/code&gt; will run this loop and return the final value of the &lt;code&gt;result&lt;/code&gt; in the computation. A &lt;code&gt;scan&lt;/code&gt; is just a fold that returns a list of the intermediate values at each iteration in the loop. Haskell has two &lt;code&gt;scan&lt;/code&gt; functions that work on lists: &lt;code&gt;scanl&lt;/code&gt; and &lt;code&gt;scanr&lt;/code&gt;. &lt;code&gt;scanl&lt;/code&gt; starts the iteration from the left side of the list and &lt;code&gt;scanr&lt;/code&gt; starts the iteration from the right side of the list.&lt;/p&gt;
&lt;p&gt;With this in mind, I wrote a scanl based function to factorize the list of input numbers.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-hs&#34;&gt;factorizeCiphertext :: [Integer] -&amp;gt; [Integer]
factorizeCiphertext lst@(x1:x2:nums) = scanl (\n1 n2 -&amp;gt; n2 `div` n1) firstFactor lst
    where firstFactor = x1 `div` (commonFactor x1 x2)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;In my first attempt at solving the problem, I thought that this was the full solution. But I kept getting runtime errors once I uploaded the answer to the website. After thinking about the problem for a little bit I realized that I&amp;rsquo;d missed out on some edge cases. There are two ways in which this solution can fail.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;If there are consecutive numbers that are identical at the &lt;em&gt;start&lt;/em&gt; of the sequence. The common factor algorithm will return the number itself. Consecutive identical numbers can be caused by either repeated characters (&amp;ldquo;AAAAAA&amp;rdquo;) or by repeated alternating characters (&amp;ldquo;ABABABA&amp;rdquo;) in the plain text.&lt;/li&gt;
&lt;li&gt;If there are multiple but different consecutive numbers at the start of the sequence. For instance, if the cipher text starts like &lt;code&gt;[9, 9, 9, 15, 15, 15, 35, 217]&lt;/code&gt;.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Note that if repeated characters appear in the middle of the sequence, it does not matter since the procedure we use will divide this number by the previous factor anyway. To handle this edge case, we&amp;rsquo;ll need to extract any successive repeated numbers from the start of the sequence. So I wrote two functions to split the input list into two lists. One contains any repeated characters at the start of the list and the other is the rest of the list.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-hs&#34;&gt;groupHead :: [Integer] -&amp;gt; [Integer]
groupHead (x:xs)
    | x == (head xs) = [x] ++ (takeWhile (==x) xs) ++ groupHead (dropWhile (==x) xs)
    | otherwise = []

groupTail :: [Integer] -&amp;gt; [Integer]
groupTail (x:xs)
    | x == (head xs) = groupTail (dropWhile (==x) xs)
    | otherwise = [x] ++ xs
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;For the rest of the list that does not have any initial repeating characters, the original &lt;code&gt;factorizeCiphertext&lt;/code&gt; function can be used to factorize the list. But how do we factorize the first part of the list? After a bit of thought I realized that if we factorize the first number in the second part of the list, it must have a common factor with the last number in the first part of the list. So now I can use this as the first factor to &lt;code&gt;scan&lt;/code&gt; the list from the right!&lt;/p&gt;
&lt;p&gt;So the final function that accounts for the edge cases is:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-hs&#34;&gt;factorizeCiphertext4 :: [Integer] -&amp;gt; [Integer]
factorizeCiphertext4 (n:nums)
    | isEdge = (scanr (\n1 n2 -&amp;gt; n1 `div` n2) (head factorTail) groupHeads) ++ (tail factorTail)
    | otherwise = factorTail
    where groupHeads = groupHead ([n] ++ nums)
          isEdge = if (length groupHeads) &amp;gt; 0 then True else False
          listToScan = groupTail ([n] ++ nums)
          firstFactor = (head listToScan) `div` (commonFactor (head listToScan) (head $ tail listToScan))
          factorTail = scanl (\f n -&amp;gt; n `div` f) firstFactor listToScan
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;You can view my full solution to the problem 
&lt;a href=&#34;https://gist.github.com/RationalAsh/5edb735044535fcc98025383d8b648ad&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;here&lt;/a&gt;.&lt;/p&gt;
&lt;h2 id=&#34;conclusion&#34;&gt;Conclusion&lt;/h2&gt;
&lt;p&gt;Haskell is a difficult language to learn, especially if you&amp;rsquo;ve only been exposed to imperative languages all your life. Rather than thinking in terms of discrete steps, you have to force yourself to think in terms of recursion and higher order patterns in the problem. However, if you stick with it for that initial amount of time that it takes to develop some basic proficiency, the results can be very rewarding. You can write some beautiful code in this language. After learning Haskell, I&amp;rsquo;ve also found myself using a functional approach to solve programming problems in other languages too! For instance, I&amp;rsquo;ve started using Python&amp;rsquo;s 
&lt;a href=&#34;https://docs.python.org/3/library/itertools.html&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;iterools&lt;/a&gt; package much more often.&lt;/p&gt;
&lt;p&gt;However, usefulness wasn&amp;rsquo;t the main factor that motivated me to learn Haskell. For me it was more about the fun of solving puzzles in clever and aesthetically pleasing ways. Haskell is one of the few languages that puts some fun back into solving programming problems. I think it brings in some of the beauty and rigor traditionally associated with pure mathematics into a programming language. If you&amp;rsquo;re someone who enjoys programming puzzles for their own sake and finds beauty in clever solutions to puzzles, I highly recommend giving Haskell a go.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>The Witcher 3: Wild Hunt - A Review</title>
      <link>https://www.ashwinnarayan.com/post/witcher-3-review/</link>
      <pubDate>Sun, 16 Sep 2018 01:10:46 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/witcher-3-review/</guid>
      <description>&lt;p&gt;The Witcher 3 follows the story of Geralt of Rivia, a Witcher or monster slayer in search of his adoptive daugter Cirllia. (well it&amp;rsquo;s not &lt;em&gt;his&lt;/em&gt; story but we see the story through his eyes!). Set in a medieval world - after an event called the conjunction of spheres - magic and monsters (werewolves, spectres, vampire and the like.) roam the world. Witchers are magically and genetically enhanced humans that were created intentionally by sorcerers to help fight off these monsters. Cirilla (or Ciri) is a woman with special magical abilities and is prophesied to play a part in the fate of Geralt&amp;rsquo;s (and others) world(s) which are facing doom from a world ending White Frost.&lt;/p&gt;
&lt;p&gt;I purchased the game almost a year ago in December 2017 after getting strong recommendations from my friends. I&amp;rsquo;ll admit that I was a little intimidated at first. It was the third game in the series and it appeared as though I had a lot of catching up to do. I needn&amp;rsquo;t have worried too much though. One of the main features of the game are the huge number of random books lying around the world. You pick them up and they often contain bits and pieces of the story of the Witcher universe. However, one thing that was definitely intimidating was the combat mechanics. There were swords (two of them!), spells (signs), potions, decoctions, oils, bombs and crossbows all bound to correspondingly wide array of keys. Although the combat mechanics tutorial at the start of the game explained most things, it&amp;rsquo;s a lot to remember. I took a short break from playing the game for a few months in between and when I came back, I&amp;rsquo;d forgotten all the keybindings and had to play through the initial combat mechanics tutorial again to get used to things. Funnily enough although I preferred playing video games with a keyboard and mouse for the increased maneuverability, I think using a controller might be slightly easier for the Witcher 3 since you don&amp;rsquo;t have to keep track of random alphabets on the keyboard.&lt;/p&gt;
&lt;p&gt;The high level of immersion is what I enjoyed the most about the game. As a person that likes a bit of realism in games, I like it when the game mechanics do not break immersion. This is something I felt while playing 
&lt;a href=&#34;http://freebirdgames.com/to_the_moon/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;To the Moon&lt;/a&gt; (brilliant game!). A lot of the progress in the game was made through solving what felt like very artificial puzzles (tile flipping jigsaws?). So it felt like alternating between experiencing the story and playing minigames. The Witcher has a ton of game mechanics but they&amp;rsquo;re all integrated into the story in a very natural way. Progress in the game is made through talking, interacting with objects and fighting. The fighting is quite realistic too. If I&amp;rsquo;m fighting a group of people they all come at me at once and I have dodge and roll between them to make sure that I don&amp;rsquo;t get hit from behind while fighting one person. Additionally, there&amp;rsquo;s no Pokemon like battle animation that signals the start of a battle. One second you&amp;rsquo;re walking along, minding your own stuff and the next second a drowner&amp;rsquo;s taking a swipe at you.&lt;/p&gt;
&lt;p&gt;The incredibly open world nature of the game is the second factor that adds to the realism and immersiveness. You can go almost anywhere on the absolutely huge map. There are practically no invisible walls that you can run into and obstacles that cannot be jumped over are at a realistic height most of the time. If you step off a cliff, you fall and if the fall is too great, you lose health and possibly die. The only invisible walls I&amp;rsquo;ve ever encountered are when you wander off to the edge of the map.&lt;/p&gt;
&lt;p&gt;The third factor that adds to the immersiveness of the game is the map itself. The world of Witcher 3 is &lt;em&gt;incredibly&lt;/em&gt; detailed. The cities like Oxenfurt and Novigrad feel like real full scale big cities. Although they are scaled down versions of the cities mentioned in the books, they&amp;rsquo;re still the biggest I&amp;rsquo;ve encountered in a video game. It was not like Pokemon where a &amp;ldquo;city&amp;rdquo; can be 4 buildings of which one is a Pokemon Center and another a Pokemart. I loved roaming around Novigrad (despite the nutjobs that are trying to burn witches alive). My favorite part of the city is probably the market square. I like how I can hear the chaotic sounds of a marketplace start up as you walk towards it. Outside the cities there are forests, snowy mountains, small villages, beaches and swamps all beatifully built and rendered in a very non-repetitive and organic way. The scenery never felt boring. It felt like nearly everything was placed and adjusted by hand. I was amazed in particular by the fantastical environments I encountered while traveling through the many parallel universes. The use of parallel universes in the game itself was quite a novel idea! I never thought that a game set in the medieval era would involve parallel universes and time travel. I saw worlds that were just deserts, worlds covered in frost, worlds with toxic gases and colorful plants. Even the modern day world (ours!) and possibly the world of Cyberpunk 2077 (another upcoming game by them) was mentioned in passing.&lt;/p&gt;
&lt;p&gt;Despite logging over 100 hours in the game over the past year, I have yet to finish all the quests in the game. I&amp;rsquo;ve completed the main story of the game but I&amp;rsquo;ve still got dozens of Witcher contracts and a few secondary quests left to finish off. On top of all that I have yet to start on the Hearts of Stone and Blood and Wine expansions of the game - which I hear are basically like two new games; adding 10 and 20 hours of playtime respectively. Looking at the scale of the game, I was quite surprised to learn that the game only took 3.5 years and 81 million USD to make (I was expecting a lot more!). The Witcher 3 is an RPG. So as expected the choices you make during quests play a part in the outcome of the game. Some decisions are clearly good/bad but in some quests 
&lt;a href=&#34;https://www.youtube.com/watch?v=MvgWlvfFJAk&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;all the choices are bad but you still have to choose&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;My only big criticism of the game is related to the combat difficulty near the start of the game. I&amp;rsquo;m not a gamer that plays games in hard mode. I play video games mainly to experience the story. So I tend to choose the lowest difficulty setting the game has. But even at the lowest difficulty, I had some trouble staying alive during some of the quests at the start of the game. I also had trouble with getting enough gold to buy things as I was spending most of my money keeping my equipment repaired (weapons and armor degrade as you use them). The problem was not too bad though and vanished as soon as I got out of White Orchard; character leveling happened much faster and I started getting gold quite a bit faster.&lt;/p&gt;
&lt;p&gt;I really enjoy playing story rich games like the Witcher 3. I feel like that is a very natural next step in the very human tradition of storytelling. We had spoken stories, then written, then acted out (movies). Interactive stories where the person experiences the story through his own actions is a very natural next step. In this regard, The Witcher stands out as the best game I&amp;rsquo;ve ever played. It manages to immerse me in the universe of Witcher 3 and feel like I&amp;rsquo;m really there. Every time I played the game, for a brief period of time I really was Geralt of Rivia. I felt what he felt, I did what he did. And in the end I felt like it had just as much (if not more) emotional impact as watching the story unfold in a movie or a book with the added advantage of being able to drive the story on my own rather than passively watch a film.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Hugo Web Development Workflow on Windows</title>
      <link>https://www.ashwinnarayan.com/post/hugo-windows-workflow/</link>
      <pubDate>Sun, 31 Dec 2017 11:41:31 +0530</pubDate>
      <guid>https://www.ashwinnarayan.com/post/hugo-windows-workflow/</guid>
      <description>&lt;p&gt;As I mentioned in 
&lt;a href=&#34;https://www.ashwinnarayan.com/post/welcome/&#34;&gt;my first article on this blog&lt;/a&gt;, I&amp;rsquo;m now using 
&lt;a href=&#34;https://gohugo.io/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Hugo&lt;/a&gt;, the static site generator to build my personal website. Due to the needs of my work environment (mostly because I need to use MS Word and certain MATLAB features on a regular basis), I&amp;rsquo;ve been primarily using Windows as my operating system for the past year or so. Having used Linux for a long time, I definitely missed the conveniences offered by shell scripting and other command line tools. However, while setting up a workflow in Windows for publishing content to my website I discovered that Windows&amp;rsquo; scripting tools are not all that bad. In fact, for anyone familiar with scripting from Linux, moving to Powershell isn&amp;rsquo;t that hard.&lt;/p&gt;
&lt;h2 id=&#34;workflow&#34;&gt;Workflow&lt;/h2&gt;
&lt;p&gt;A typical Hugo website development folder looks like this:
&lt;img src=&#34;https://www.ashwinnarayan.com/img/hugo_folders.jpg&#34; alt=&#34;Folder Structure&#34;&gt;&lt;/p&gt;
&lt;p&gt;I add new posts by creating new markown (.md) files in the &lt;code&gt;post&lt;/code&gt; folder. When the website is compiled using the &lt;code&gt;hugo&lt;/code&gt; command, the static website&amp;rsquo;s code is generated into the &lt;code&gt;public&lt;/code&gt; folder. The content inside this is what goes into the folder that is served by any webserver. Since I am hosting the website on Github Pages, I found it most convenient to set up a separate folder with a clone of the &lt;code&gt;username.githug.io&lt;/code&gt; repository. After article writing/editing is done, I can generate the website and copy the contents inside the &lt;code&gt;public&lt;/code&gt; folder to the repository folder to publish.&lt;/p&gt;
&lt;p&gt;When I am editing an article, I can preview content locally by using the &lt;code&gt;hugo server --watch&lt;/code&gt; command in the top level directory. This sets up a local webserver on &lt;code&gt;localhost:1313&lt;/code&gt; so that you can preview the website.&lt;/p&gt;
&lt;p&gt;To publish my website to Github pages after I&amp;rsquo;m done with development, I copy everything inside the &lt;code&gt;public&lt;/code&gt; folder into my local copy of the github repository and then commit all and push.&lt;/p&gt;
&lt;h2 id=&#34;batch-script-automation&#34;&gt;Batch Script Automation&lt;/h2&gt;
&lt;p&gt;Most of the the steps in the workflow can be automated away using batch scripts to save large amounts of time. I mean, who wants to spend time manually copying files and commiting after every small edit to the website? The &lt;code&gt;build_on_laptop.bat&lt;/code&gt; file in the top level directory handles everything. Diving into the source, I first delete everything inside the &lt;code&gt;public&lt;/code&gt; folder (Hugo does not automatically do this) and build a fresh version of the website.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-dos&#34;&gt;rmdir /S /Q public
hugo
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;My Github pages repo has a few files that are not generated by Hugo. So I can&amp;rsquo;t just nuke the folder and delete everything. So I have a set of commands that delete all the Hugo generated files in the repository folder:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-dos&#34;&gt;rmdir /S /Q &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\categories&amp;quot;
rmdir /S /Q &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\css&amp;quot;
rmdir /S /Q &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\fonts&amp;quot;
rmdir /S /Q &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\home&amp;quot;
rmdir /S /Q &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\img&amp;quot;
rmdir /S /Q &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\js&amp;quot;
rmdir /S /Q &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\post&amp;quot;
rmdir /S /Q &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\project&amp;quot;
rmdir /S /Q &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\publication&amp;quot;
rmdir /S /Q &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\publication_types&amp;quot;
rmdir /S /Q &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\tags&amp;quot;
rmdir /S /Q &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\talk&amp;quot;
del &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\404.html&amp;quot;
del &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\index.html&amp;quot;
del &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\index.xml&amp;quot;
del &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\sitemap.xml&amp;quot;
del &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\site.webmanifest&amp;quot;
del &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io\styles.css&amp;quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Then comes the task of copying your updated website source into the folder. While it&amp;rsquo;s possible to use the &lt;code&gt;cp&lt;/code&gt; command, I found that the &lt;code&gt;robocopy&lt;/code&gt; 
&lt;a href=&#34;https://technet.microsoft.com/en-us/library/cc733145.aspx?f=255&amp;amp;MSPPError=-2147217396&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;command&lt;/a&gt; is in general much better for copying files around in Windows.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-dos&#34;&gt;robocopy public &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io&amp;quot; /E
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Finally, I need to commit the new version of the website and push to github. This is also easily done:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-dos&#34;&gt;cd &amp;quot;C:\Users\Ashwin Narayan\rationalash.github.io&amp;quot;
set /p commitmsg=&amp;quot;Enter a commit message: &amp;quot;
git add --all .
git commit -m &amp;quot;%commitmsg%&amp;quot;
git push origin master
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;So the end result is that when I run this script, it automatically deletes everything in the public folder and the repository folder, rebuilds and copies the new website over and then commits and pushes the new version to github to deploy the website.&lt;/p&gt;
&lt;h2 id=&#34;even-more-automation-with-visual-studio-code&#34;&gt;Even More Automation with Visual Studio Code&lt;/h2&gt;
&lt;p&gt;I can shave even more time off the workflow by using Visual Studio Code. VS Code has a really well made task management system. It&amp;rsquo;s also a natural choice since I do most of my markdown editing inside VS Code anyway. VS Code has a &lt;code&gt;tasks.json&lt;/code&gt; file where you can bind custom tasks/commands to key combinations. In this case, I just bound the default build task mapped to &lt;code&gt;Ctrl&lt;/code&gt;+&lt;code&gt;Alt&lt;/code&gt;+&lt;code&gt;B&lt;/code&gt; to the batch script. I also created a compose task which creates the local preview webserver.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-json&#34;&gt;{
    // See https://go.microsoft.com/fwlink/?LinkId=733558
    // for the documentation about the tasks.json format
    &amp;quot;version&amp;quot;: &amp;quot;0.1.0&amp;quot;,
    &amp;quot;tasks&amp;quot;: [
        {
            &amp;quot;taskName&amp;quot;: &amp;quot;build&amp;quot;,
            &amp;quot;command&amp;quot;: &amp;quot;build_on_laptop.bat&amp;quot;,
            &amp;quot;isShellCommand&amp;quot;: true,
            &amp;quot;showOutput&amp;quot;: &amp;quot;always&amp;quot;,
            &amp;quot;echoCommand&amp;quot;: true
        },
        {
            &amp;quot;taskName&amp;quot;: &amp;quot;compose&amp;quot;,
            &amp;quot;command&amp;quot;: &amp;quot;hugo&amp;quot;,
            &amp;quot;args&amp;quot;: [&amp;quot;server&amp;quot;, &amp;quot;--watch&amp;quot;],
            &amp;quot;isShellCommand&amp;quot;: true,
            &amp;quot;showOutput&amp;quot;: &amp;quot;always&amp;quot;,
            &amp;quot;echoCommand&amp;quot;: true
        }
    ]    
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;With most of the steps automated, writing and publishing new articles don&amp;rsquo;t take that long compared to off the shelf solutions like Wordpress or Medium. It also comes with the advantage that you have full control over the website&amp;rsquo;s source code.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>My Review of Star Trek: Discovery</title>
      <link>https://www.ashwinnarayan.com/post/star-trek-discovery/</link>
      <pubDate>Sun, 10 Dec 2017 23:26:48 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/star-trek-discovery/</guid>
      <description>&lt;div class=&#34;alert alert-warning&#34;&gt;
  &lt;div&gt;
    This article contains spoilers for all the episodes of Star Trek: Discovery.
  &lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;As a lover of good science fiction I was really happy to hear the announcement of Star Trek: Discovery. I have not watched all of old Star Trek. But from the few that I have watched (Mostly Star Trek: Then Next Generation), I have come to love the Trek universe and the way it handles science fiction. I feel that of late, science fiction is leaning too much towards dystopian themes. I like the occasional story about a world in nuclear winter but I like optimistic or neutral science fiction far more. It appeals to the part of me that gets excited about science and my penchant for the cool technologies and knowledge that it generates. So stories like 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Contact_%28novel%29&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Contact&lt;/a&gt; and 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Rendezvous_with_Rama&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Rendezvous with Rama&lt;/a&gt; is much more up my alley. I consider even movies like 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Interstellar_%28film%29&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Interstellar&lt;/a&gt; as optimistic science fiction since even though the premise is that the earth is becoming uninhabitable, the story is that we work together to build the technology to colonize the stars. I consider 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Her_%28film%29&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Her&lt;/a&gt; science fiction although the focus of the movie was the relationship between Theodore and Samantha. The movie portrayed beautiful cityscapes and a future which looked distinctly 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Post-scarcity_economy&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;post-scarcity&lt;/a&gt; as the characters seemed to not have to worry about basic needs and could live comfortably while doing basically whatever they wanted. In the case of Star Trek (at least for Star Trek: TnG) the episodes that I&amp;rsquo;ve watched so far fall under &lt;em&gt;very&lt;/em&gt; optimistic science fiction.&lt;/p&gt;
&lt;p&gt;One of my biggest fears about Star Trek: Discovery was that it would devolve into an action flick - especially because of the way the trailer was cut. It seemed to focus more on the action and less on the discovery/science/exploration part while also making the whole thing look like yet another dystopian sci-fi series. I felt that first two episodes seemed to run with this theme so much that they turned me away from the series initially and I took a break from it for nearly a month. But I came back to it one weekend when I was bored - and I&amp;rsquo;m glad I did. The episodes got better and so did the themes in them. While there was still an appreciable amount of action, they did not ignore the exploration and discovery part of things and. I also like that they specifically included characters whose biggest motivation was scientific curiosity. Here are some parts of the show that I particularly enjoyed:&lt;/p&gt;
&lt;h2 id=&#34;1-the-warp-capable-tardigrade&#34;&gt;1. The Warp Capable Tardigrade&lt;/h2&gt;
&lt;p&gt;&lt;img src=&#34;https://www.ashwinnarayan.com/img/tardigrade-teleports.gif&#34; alt=&#34;Warp Capable Tardigrade&#34;&gt;
Basing the strange creature on the real world 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Tardigrade&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;tardigrade&lt;/a&gt; was a really cool idea. Apart from the fact that the creature looked really cool, I like that they treated it with kindness (at least in the case of Burnham) and let it go at the end.&lt;/p&gt;
&lt;h2 id=&#34;2-the-mycelial-network-and-the-spore-drive&#34;&gt;2. The Mycelial Network and The Spore Drive&lt;/h2&gt;
&lt;p&gt;&lt;img src=&#34;https://www.ashwinnarayan.com/img/black-alert2.gif&#34; alt=&#34;Spore Drive&#34;&gt;
I was nerding out when the show started talking about a giant fungus spanning the entire universe because it&amp;rsquo;s actually based on an amazing real world fungus called the 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Armillaria_ostoyae&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;&lt;em&gt;Armillaria ostoyae&lt;/em&gt;&lt;/a&gt;  which is often reported as one of the largest living organisms in the world. There&amp;rsquo;s a single fungal colony of this type in the Malheur National Forest in the Blue Mountains of eastern Oregon, U.S, spanning 8.9 square kilometers. It&amp;rsquo;s estimated to be 2400 years old. The spore drive animations are amazing and it&amp;rsquo;s a creative plot device too.&lt;/p&gt;
&lt;h2 id=&#34;3-the-imperfect-captain&#34;&gt;3. The Imperfect Captain&lt;/h2&gt;
&lt;p&gt;&lt;img src=&#34;https://www.ashwinnarayan.com/img/gabriel_lorca.jpg&#34; alt=&#34;Gabriel Lorca&#34;&gt;
In the older Star Treks, I felt that the captains tended to be very &amp;ldquo;perfect&amp;rdquo; characters (Kirk, Picard). They tended to be the kind of characters that are &lt;em&gt;obviously&lt;/em&gt; good. However, the captain of the U.S.S Discovery is quite a bit less than perfect. In fact, he does quite a lot of things that are decidedly in the gray zone. In fact, the way he was introduced in the series is very similar to how villians are sometimes introduced in films. This gave me an initial sense of apprehension about the character - I got a fleeting sense that this dude is a bit evil and might not up to any good. In fact, I spent most of the episodes expecting something sinister to happen and for Lorca to pull an Admiral Marcus (Into Darkness) and reveal that he is in fact on the dark side of the force. But &lt;em&gt;that&lt;/em&gt; never happened. Now I feel like he is a good captain who just has some unusual interest in war and does the odd unethical thing to get what he wants. Whatever the case, he added a lot of interest and depth to the new Star Trek and I like that he was not the same type of Captain as Kirk or Picard. In fact, I thought that Gabriel Lorca was a more interesting character than Michael Burnham (who I feel the showrunners are trying to make &lt;em&gt;the&lt;/em&gt; main character.).&lt;/p&gt;
&lt;h2 id=&#34;summing-up&#34;&gt;Summing Up&lt;/h2&gt;
&lt;p&gt;I feel that Star Trek: Discovery was well executed. While it is not exactly the same as the original Star Treks, I feel that the parts that were changed added more to the story than it took away. I like the mid season &amp;ldquo;finale&amp;rdquo; in which the crew of the Discovery were stranded in what seemed to be an alternate dimension. It is reminiscent of the TNG episode 
&lt;a href=&#34;http://memory-alpha.wikia.com/wiki/Where_No_One_Has_Gone_Before_%28episode%29&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;&amp;ldquo;Where No One Has Gone Before&amp;rdquo;&lt;/a&gt; in which the crew does some crazy new warp technique to go to the edge of the known universe. I look forward to seeing release of rest of the season next year. I&amp;rsquo;m curious to find out how they will handle the parallel universes thing.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>How to Integrate Quaternions</title>
      <link>https://www.ashwinnarayan.com/post/how-to-integrate-quaternions/</link>
      <pubDate>Sun, 10 Sep 2017 17:58:08 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/how-to-integrate-quaternions/</guid>
      <description>&lt;p&gt;I&amp;rsquo;ve been working with inertial measurement units lately, and I&amp;rsquo;ve come to realize that there&amp;rsquo;s a surprising amount of mathematics involved in processing the raw data from the sensors. The story begins with me trying to integrate a three-dimensional angular velocity vector to get the orientation of an object. It turns out that while angular velocity is a vector, common representations of orientation, like Euler Angles, are not. So calculating the orientation is not as simple as integrating the angular velocity vector over time ($\int_0^t \vec{\omega} \mathscr{d}t$).&lt;/p&gt;
&lt;p&gt;Rotations in two dimensions are simple because there is only one plane in which you can rotate. The only variable that can be freely set is the center of rotation. So you can represent the orientation of an object in 2D by a single angle $\phi$. The angular velocity of an object in two dimensions can also be represented by a single number $\omega$, the time derivative of the angle. This produces the familiar formula I learned in high school physics.&lt;/p&gt;
&lt;p&gt;$$\omega = \frac{d\phi}{dt} = \frac{v_{\bot}}{r}$$
&lt;img src=&#34;https://www.ashwinnarayan.com/img/angular_velocity.svg&#34; alt=&#34;angular_velocity_image&#34;&gt;&lt;/p&gt;
&lt;p&gt;Rotations in 3D are much more complicated. In 3 dimensions, the plane of rotation can be any among an infinite number of possibilities. The origin or &amp;ldquo;center&amp;rdquo; of rotation now becomes an &lt;em&gt;axis&lt;/em&gt; of rotation which is represented by a vector. The plane of rotation is perpendicular to the axis of rotation. This is a result of the 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Euler%27s_rotation_theorem&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Euler Rotation Theorem&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Before I can start integrating angular velocity I need to choose a representation for the orientation. There are several different conventions when it comes to representing the orientation of an object in 3D. The most popular approach is to use a set of three angles called 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Euler_angles&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Euler Angles&lt;/a&gt;. This approach was developed by the mathematician Leonhard Euler (pronounced oy-ler not you-ler). These set of three angles specify three successive rotations around three different axes in a very specific order. The order is important because rotations in 3D have an important property: they do not &lt;em&gt;commute&lt;/em&gt;. This means that if I do rotation 1 before 2 I end up with a different orientation than if I do 2 before 1. Euler angles usually specify rotations in the ZXZ order. This means that the first axis of rotation is the current Z-axis. The second axis of rotation is the new X-axis &lt;em&gt;after&lt;/em&gt; the first rotation. The final axis of rotation is the new Z-axis after the first and second rotations. A closely related approach is to use what&amp;rsquo;s called 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Euler_angles#Tait-Bryan_angles&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Tait-Bryan angles&lt;/a&gt;. Tait-Bryan angles are called yaw, pitch and roll and are commonly used when talking about the orientation of aircraft. The angles represent successive rotations around the body fixed X, Y and Z axes. Both Euler angles and Tait-Bryan angles however, suffer from something called 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Gimbal_lock&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Gimbal Lock&lt;/a&gt;. This is when for a certain value of one of the rotation angles, a degree of freedom is lost and two rotations &amp;ldquo;collapse&amp;rdquo; into a single rotation. The Wikipedia page linked has some nice visualizations and a short mathematical explanation (using rotation matrices) for why this happens.&lt;/p&gt;
&lt;p&gt;Using Quaternions to represent rotations is a way to avoid the Gimbal Lock problem. Quaternions are so useful for representing orientations that most Kalman Filters that need to track 3D orientations use them instead of Euler Angles. So I settled on using quaternions. When I first started working with quaternions I found them a little difficult to understand. So I thought of writing an article about the path I took to understand and use quaternions for &amp;ldquo;integrating&amp;rdquo; angular velocity.&lt;/p&gt;
&lt;p&gt;From all my time working with mathematics, I&amp;rsquo;ve come to realize that mathematical ideas exist on a spectrum. At one end is math that is focused on the practical application. Math that is very close to the real world (as experienced by humans) and can be understood easily by making analogies to things that humans encounter in everyday life. This is the type of math that is often applied to solve everyday problems like settling bills or building bridges. At the other end of the spectrum is the type of math that is pure abstraction. This type of abstract math is often used to generalize specific results in practical math to other problems or to come up with new insights that can pave the way for new solutions to a problem. Quaternions are a little more towards the abstract end of the spectrum and can be difficult to get an intuition for. Sometimes though there are ideas that you &lt;em&gt;can&amp;rsquo;t&lt;/em&gt; get an intuition for. Working with such math is mostly a matter of getting used to it. With abstract math, the best way I&amp;rsquo;ve found to get used to it is to learn the basic definition and keep applying it to problems until you get the hang of it. The understanding forms in the brain automatically as you get the hang of it.&lt;/p&gt;
&lt;h2 id=&#34;quaternion-math&#34;&gt;Quaternion Math&lt;/h2&gt;
&lt;p&gt;So without further ado, I&amp;rsquo;ll talk about what quaternions are and how they behave.&lt;/p&gt;
&lt;h3 id=&#34;representation&#34;&gt;Representation&lt;/h3&gt;
&lt;p&gt;A quaternion $q$ can be represented as a tuple of 4 numbers:
$$q = \begin{bmatrix} w &amp;amp; \ x &amp;amp;\ y &amp;amp; \ z \end{bmatrix} = \begin{bmatrix} w &amp;amp; \ \vec{v}\end{bmatrix} = w + x\mathrm{i} + y\mathrm{j} + z\mathrm{k} $$&lt;/p&gt;
&lt;p&gt;where the $w$ is the &lt;em&gt;scalar&lt;/em&gt; part and the $\vec{v}$ is the &lt;em&gt;vector&lt;/em&gt; part.&lt;/p&gt;
&lt;p&gt;Two binary operations are defined for quaternions: addition $+$ and quaternion multiplication $\otimes$.&lt;/p&gt;
&lt;h3 id=&#34;addition&#34;&gt;Addition&lt;/h3&gt;
&lt;p&gt;Addition is defined as the component-wise sum just like for a 4D vector. The sum is commutative (order is not important) and associative (grouping is not important).&lt;/p&gt;
&lt;p&gt;$$ q_1 + q_2 = \begin{bmatrix} w_1 + w_2 &amp;amp; \ x_1 + x_2 &amp;amp; \ y_1 + y_2 &amp;amp; \ z_1 + z_2 \end{bmatrix} = q_2 + q_1$$&lt;/p&gt;
&lt;h3 id=&#34;multiplication&#34;&gt;Multiplication&lt;/h3&gt;
&lt;p&gt;Quaternion multiplication is defined in multiple ways but the formula that I find the easiest to remember is:
$$ q_1 \otimes q_2 = \begin{bmatrix} w_1 w_2 - \vec{v}_1\cdot\vec{v}_2 &amp;amp; \ w_1\vec{v}_2 + w_2\vec{v}_1 + \vec{v}_1\times\vec{v}_2 \end{bmatrix} $$&lt;/p&gt;
&lt;p&gt;The multiplication is &lt;em&gt;non-commutative&lt;/em&gt; ($q_1 \otimes q_2 \neq q_2 \otimes q_1$ ) and distributive over the sum $(q_1 \otimes (q_2 + q_3) = q_1 \otimes q_2 + q_1 \otimes q_3 )$.&lt;/p&gt;
&lt;h3 id=&#34;norm-conjugate-and-inverse&#34;&gt;Norm, Conjugate and Inverse&lt;/h3&gt;
&lt;p&gt;It&amp;rsquo;s also useful to define the norm of a quaternion as:
$$ ||q|| = \sqrt{w^2 + x^2 + y^2 + z^2} $$&lt;/p&gt;
&lt;p&gt;a conjugate quaternion $ q^* $ that satisfies the property $ q \otimes q^* = ||q||^2 $ as
$$ q^* = \begin{bmatrix} w &amp;amp; \ -x &amp;amp; \ -y &amp;amp; \ -z \end{bmatrix} $$&lt;/p&gt;
&lt;p&gt;and a quaternion inverse $q^{-1}$ with the property $q \otimes q^{-1} = \begin{bmatrix} 1 \ 0 \ 0 \ 0 \end{bmatrix}$ as
$$ q^{-1} = \frac{q^*}{||q||^2} $$&lt;/p&gt;
&lt;h2 id=&#34;using-quaternions-for-rotation&#34;&gt;Using Quaternions for Rotation&lt;/h2&gt;
&lt;p&gt;Now that the behaviour of quaternions are established, there is the question of how to use them to represent 3D rotation. From Euler&amp;rsquo;s Rotation Theorem it is clear that rotations have 3 degrees of freedom. But quaternions as 4 tuples have 4 degrees of freedom. So an additional constraint needs to be imposed to use them to represent rotations. This is done by requiring that the quaternions are &lt;em&gt;unit&lt;/em&gt; quaternions: $||q|| = 1$. Unit quaternions are also called &lt;em&gt;versors&lt;/em&gt;. There are many diagrams and visualizations that attempt to make understanding the unit quaternion more intuitive but I found that for me, most were misleading. I found it the most useful to think of quaternions as just an abstract object with the properties that I&amp;rsquo;ve mentioned and &lt;em&gt;not&lt;/em&gt; trying to have any picture in mind. The moment I left behind the crutch of visualization and forced myself to accept and think about quaternions as they are, everything fell into place.&lt;/p&gt;
&lt;p&gt;To rotate a 3D vector $\vec{r}$ by a versor $q$ an operation called &lt;em&gt;conjugation&lt;/em&gt; is used.
$$ \vec{r}&amp;rsquo; = q \otimes \begin{bmatrix} 0 &amp;amp; \ \vec{r} \end{bmatrix} \otimes q^{*} $$&lt;/p&gt;
&lt;p&gt;If I find the formula quite mysterious (as I did when I first saw it), it&amp;rsquo;s helpful to use one of the other methods (euler angles, axis angle) to rotate a vector and verify that the result is the same.&lt;/p&gt;
&lt;p&gt;It&amp;rsquo;s possible to compose two rotations represented by two quaternions $q_1$ and $q_2$ by multiplying the two quaternions together $q_2 \otimes q_1$. This product represents the rotation $q_1$ applied before $q_2$.&lt;/p&gt;
&lt;h3 id=&#34;quaternions-rotation-matrices-and-the-rotation-group-so3&#34;&gt;Quaternions, Rotation Matrices and the Rotation Group $SO(3)$&lt;/h3&gt;
&lt;p&gt;Earlier, I mentioned that rotations in 3D have certain properties (like non-commutativity) that implies that they don&amp;rsquo;t belong to a vector space (and therefore can&amp;rsquo;t be represented by one). If I want to be exact when talking about rotations, I have to consider them as a &lt;em&gt;group&lt;/em&gt;. A group is yet another mathematical abstraction. Abstractly, think of them as a set of objects that follow certain rules. Remember that groups are another concept that leans towards the abstract end of the mathematical spectrum. They &lt;em&gt;can&lt;/em&gt; be applied to rotations but they were invented by mathematicians to study more general ideas. So what rules does a group follow?&lt;/p&gt;
&lt;p&gt;A group is a set $G$ along with some &lt;em&gt;binary&lt;/em&gt; operation $\cdot$ (takes two elements of the set and gives a third). The elements of the set follow these rules:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Closure: If $a,b \in G$ then $a\cdot b \in G$.&lt;/li&gt;
&lt;li&gt;Associativity: If $a,b,c \in G$ then $a\cdot ( b \cdot c) = (a \cdot b) \cdot c $.&lt;/li&gt;
&lt;li&gt;Identity: There&amp;rsquo;s some element of the set $e$ which has the property $a \cdot e = e\cdot a = a$.&lt;/li&gt;
&lt;li&gt;Inverse: If $a \in G$ there&amp;rsquo;s some element $a^* $ such that $a \cdot a^* = a^* \cdot a = e$.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;If you compare this to 3D rotations, you can see that the set of 3D rotations are an example of a group under the binary operation of composition (doing one rotation after another)!&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Closure: If I compose two rotations it forms another rotation. It doesn&amp;rsquo;t suddenly become a translation or scaling or shear. There&amp;rsquo;s no way to combine rotations to do any of these other operations.&lt;/li&gt;
&lt;li&gt;Associativity: If I do three rotations, it doesn&amp;rsquo;t matter which two I compose first.&lt;/li&gt;
&lt;li&gt;Identity: There&amp;rsquo;s an identity rotation ($0^\circ$ of rotation around any axis).&lt;/li&gt;
&lt;li&gt;And there&amp;rsquo;s an inverse rotation (rotating by negative of the angle around the same axis.)&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Quaternions under multiplications &lt;em&gt;also&lt;/em&gt; satisfy all these properties.&lt;/p&gt;
&lt;p&gt;If I convert Euler angle rotations to rotation matrices and compare them with quaternions, the parallels between them are very clear.&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Group Property&lt;/th&gt;
&lt;th&gt;Rotation Matrix $R_i \in G$&lt;/th&gt;
&lt;th&gt;Quaternion $q_i \in \mathbb{H}_R$&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Closure&lt;/td&gt;
&lt;td&gt;$R_1 \cdot R_2 \in G$&lt;/td&gt;
&lt;td&gt;$q_1 \otimes q_2 \in \mathbb{H}_R$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Associativity&lt;/td&gt;
&lt;td&gt;$R_1 \cdot (R_2 \cdot R_3) = (R_1 \cdot R_2) \cdot R_3$&lt;/td&gt;
&lt;td&gt;$q_1 \otimes (q_2 \otimes q_3) = (q_1 \otimes q_2) \otimes q_3$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Identity&lt;/td&gt;
&lt;td&gt;$I$&lt;/td&gt;
&lt;td&gt;$1$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Inverse&lt;/td&gt;
&lt;td&gt;$R_i^{-1} = R_i^{T} $&lt;/td&gt;
&lt;td&gt;$q_i^{-1}$&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;The closure and associativity properties rotation matrices can be easily seen as a consequence of the fact that rotation matrices are 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Orthogonal_matrix&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;orthogonal matrices&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;With this knowledge of the rules that rotations follow, it&amp;rsquo;s clear why it&amp;rsquo;s silly to think of the Euler angles as a vector. They&amp;rsquo;re a set of related numbers but vectors they are not! It&amp;rsquo;s also clear why integrating the angular velocity vector over time does not directly give the orientation in an easily usable form.&lt;/p&gt;
&lt;h3 id=&#34;representing-quaternion-rotation-as-a-matrix&#34;&gt;Representing quaternion rotation as a matrix&lt;/h3&gt;
&lt;p&gt;Linearity of operations are an important property that both engineers and mathematicians like to take advantage of. It can result in useful simplifications of results. So it&amp;rsquo;s useful (later in this article) to ask the question: Is quaternion multiplication a linear operation? The simplest way to find out is to write out the result of a general quaternion multiplication operation and check if it&amp;rsquo;s possible to represent it as a matrix multiplication.&lt;/p&gt;
&lt;p&gt;The symbolic result of multiplying two quaternions $q_1$ and $q_2$ is:
$$ q_1 \otimes q_2 = \left[\begin{matrix}w_1 w_2 - x_1 x_2 - y_1 y_2 - z_1 z_2\\ w_1 x_2 + w_2 x_1 + y_1 z_2 - y_2 z_1\\ w_1 y_2 + w_2 y_1 - x_1 z_2 + x_2 z_1\\ w_1 z_2 + w_2 z_1 + x_1 y_2 - x_2 y_1\end{matrix}\right] $$&lt;/p&gt;
&lt;p&gt;From inspection, this can be written as a matrix product:
$$ q_1 \otimes q_2 = \left[\begin{matrix}w_2 &amp;amp; -x_2 &amp;amp; -y_2 &amp;amp; -z_2\\ x_2 &amp;amp; w_2 &amp;amp; z_2 &amp;amp; - y_2\\ y_2 &amp;amp; - z_2 &amp;amp; w_2 &amp;amp; x_2\\ z_2 &amp;amp; y_2 &amp;amp; - x_2 &amp;amp; w_2\end{matrix}\right] \begin{bmatrix} w_1 \\ x_1 \\ y_1 \\ z_1 \end{bmatrix} $$&lt;/p&gt;
&lt;p&gt;And if I change the order of multiplication:
$$ q_2 \otimes q_1 = \left[\begin{matrix}w_2 &amp;amp; - x_2 &amp;amp; - y_2 &amp;amp; - z_2 \\ x_2 &amp;amp; w_2 &amp;amp; - z_2 &amp;amp; y_2 \\ y_2 &amp;amp; z_2 &amp;amp; w_2 &amp;amp; - x_2 \\ z_2 &amp;amp; - y_2 &amp;amp; x_2 &amp;amp; w_2\end{matrix}\right] \begin{bmatrix} w_1 \\ x_1 \\ y_1 \\ z_1 \end{bmatrix} $$&lt;/p&gt;
&lt;h2 id=&#34;integrating-angular-velocity&#34;&gt;Integrating Angular Velocity&lt;/h2&gt;
&lt;p&gt;To properly integrate angular velocity to get a quaternion, I need to find a relationship between quaternions and angular velocity - or more precisely - a differential equation that relates the time derivative of the quaternion $\dot{q}$ and the angular velocity vector $\vec{\omega}$.&lt;/p&gt;
&lt;p&gt;A natural place to start is the original definition of the angular velocity from physical law. If I imagine a vector of constant $\vec{s}(t)$ length stretching out from the origin undergoing rotation with the instantaneous angular velocity $\vec{\omega}(t)$ I can find the velocity at the tip of this vector by taking it&amp;rsquo;s derivative.
$$ \frac{\mathrm{d}\vec{s}}{\mathrm{d}t} = \vec{\omega} \times \vec{s} $$&lt;/p&gt;
&lt;p&gt;Since the angular velocity is perpendicular to the vector $\vec{s}$ (driving their dot product $\vec{\omega} \cdot \vec{s}$ to zero) the equation can also be written in quaternion form as:
$$ \frac{\mathrm{d}\vec{s}}{\mathrm{d}t} = \vec{\omega} \otimes \vec{s} $$&lt;/p&gt;
&lt;p&gt;Now I imagine that this instantaneous vector is represented by a quaternion $q$ rotation from a constant vector $\vec{s}_0$.
$$\begin{align} \vec{s} &amp;amp;= q \otimes \vec{s}_0 \otimes q^* \\
\frac{\mathrm{d}\vec{s}}{\mathrm{d}t} &amp;amp;= \frac{\mathrm{d}}{\mathrm{d}t} \left[ q \otimes \vec{s}_0 \otimes q^* \right]
\end{align}$$&lt;/p&gt;
&lt;p&gt;So how do I take that nasty looking derivative on the side? Well it turns out that the product rule of derivatives that is valid in basic calculus is also perfectly valid for quaternion multiplication! I converted the quaternion product into a matrix multiplication and spent some time converting the derivatives of the product to the result from applying the product rule. The only thing to watch out for is the non commutativity of the multiplication. The order of the quaternion product shouldn&amp;rsquo;t be changed when applying the product rule.&lt;/p&gt;
&lt;p&gt;$$ \frac{\mathrm{d}}{\mathrm{d}t} \left[ q \otimes \vec{s}_0 \otimes q^* \right] =  \dot{q} \otimes \vec{s}_0 \otimes q^* +  q \otimes \vec{s}_0 \otimes \dot{q^*} $$&lt;/p&gt;
&lt;p&gt;There&amp;rsquo;s a term in this equation - the derivative of the conjugate - that&amp;rsquo;ll cause some trouble. It is possible to eliminate this using other methods but the simplest way is to directly find a relationship between $\dot{q}$ and $\dot{q^*}$. The easy way to do this is to take the derivative of the product of a quaternion and it&amp;rsquo;s conjugate which we know to be 1:&lt;/p&gt;
&lt;p&gt;$$\begin{align}
\frac{\mathrm{d}}{\mathrm{d}t} (q \otimes q^* ) &amp;amp;=  \frac{\mathrm{d}}{\mathrm{d}t} 1 \\
\dot{q} \otimes q^* + q \otimes \dot{q^*} &amp;amp;= 0 \end{align} $$&lt;/p&gt;
&lt;p&gt;That gives the relationship&lt;/p&gt;
&lt;p&gt;$$ \dot{q^* } = -q^* \otimes \dot{q} \otimes q^* $$&lt;/p&gt;
&lt;p&gt;Expressing $s_0$ in terms of $s$, substituting $\dot{q^* } $ and doing a little algebra:
$$ \frac{\mathrm{d}}{\mathrm{d}t} \left[ q \otimes \vec{s}_0 \otimes q^* \right] =  \dot{q} \otimes q^* \otimes \vec{s} -  \vec{s} \otimes \dot{q} \otimes q^* = \vec{\omega} \otimes \vec{s} $$&lt;/p&gt;
&lt;h3 id=&#34;the-quaternion-commutator&#34;&gt;The Quaternion Commutator&lt;/h3&gt;
&lt;p&gt;The expression $\dot{q} \otimes q^* \otimes \vec{s} -  \vec{s} \otimes \dot{q} \otimes q^*$ is in the form $p \otimes q - q \otimes p$ which is defined as a commutator operation written as $[p, q]$. Going through the algebra of this operation and simplifying:&lt;/p&gt;
&lt;p&gt;$$ [q_1, q_2] = \begin{bmatrix} 0 \ 2(\vec{v}_1 \times \vec{v}_2) \end{bmatrix} $$&lt;/p&gt;
&lt;p&gt;Interestingly, if both $q_1$ and $q_2$ are &lt;em&gt;pure quaternions&lt;/em&gt; (They do not have a scalar part) then the quaternion commutator and the product are related:&lt;/p&gt;
&lt;p&gt;$$[\vec{q}_1, \vec{q}_2] = 2(q_1 \times q_2) = 2(q_1 \otimes q_2) $$&lt;/p&gt;
&lt;h3 id=&#34;the-product-dotq-q--is-a-pure-quaternion&#34;&gt;The Product $\dot{q} q^* $ is a Pure Quaternion&lt;/h3&gt;
&lt;p&gt;$$\begin{align} \dot{q} \otimes q^* + q \otimes \dot{q^* } &amp;amp;= 0 \\
\dot{q} \otimes q^* &amp;amp;= -(\dot{q} \otimes q^* )^*
\end{align} $$&lt;/p&gt;
&lt;p&gt;Saying that a $q = -q^* $ is the same as saying that $w = -w$ which means that the scalar part of the quaternion is zero.&lt;/p&gt;
&lt;h3 id=&#34;the-differential-equation&#34;&gt;The Differential Equation&lt;/h3&gt;
&lt;p&gt;So finally, I can extract the quaternion differential equation:&lt;/p&gt;
&lt;p&gt;$$ \begin{align}  \dot{q} \otimes q^* \otimes \vec{s} -  \vec{s} \otimes \dot{q} \otimes q^* &amp;amp;= \vec{\omega} \otimes \vec{s} \\
\left[\dot{q} \otimes q^* , \vec{s}\right] &amp;amp;= \vec{\omega} \otimes \vec{s} \\
2\dot{q} \otimes q^* \otimes \vec{s} &amp;amp;= \vec{\omega} \otimes \vec{s} \\
\dot{q} &amp;amp;= \frac{1}{2} \vec{\omega} \otimes q \end{align} $$&lt;/p&gt;
&lt;p&gt;In this equation the $\vec{\omega}$ is the angular velocity in the global fixed frame. In many situations it&amp;rsquo;s more useful to have an equation in terms of the angular velocity as measured by a reference frame fixed to the moving body - like when it is measured using a gyroscope. The angular velocity in this frame is the global angular velocity rotated into the body frame $\vec{\omega}&amp;rsquo; = q^* \otimes\vec{\omega}\otimes q $. Replacing $\vec{\omega}$ gives the more useful differential equation:&lt;/p&gt;
&lt;p&gt;$$ \dot{q} = \frac{1}{2} q \otimes  \vec{\omega} $$&lt;/p&gt;
&lt;h3 id=&#34;integration&#34;&gt;Integration&lt;/h3&gt;
&lt;p&gt;To solve this differential equation is to be able to integrate it. Normal differential equations are difficult enough. How does one solve a differential equation with a &lt;em&gt;quaternion multiplication&lt;/em&gt; in it? This is where the linearity of the quaternion multiplication becomes very useful. I am also going to make a (reasonable) assumption - that the angular velocity is constant over a time $\Delta t$. Then I can rewrite the differential equation in a well known form:&lt;/p&gt;
&lt;p&gt;$$ \begin{bmatrix} \dot{w} \\ \dot{x} \\ \dot{y} \\ \dot{z} \end{bmatrix} = \frac{1}{2} \cdot \left[\begin{matrix}0 &amp;amp; - \omega_x &amp;amp; - \omega_y &amp;amp; - \omega_z \\ \omega_x &amp;amp; 0 &amp;amp; \omega_z &amp;amp; - \omega_y \\ \omega_y &amp;amp; - \omega_z &amp;amp; 0 &amp;amp; \omega_x \\ \omega_z &amp;amp; \omega_y &amp;amp; - \omega_x &amp;amp; 0 \end{matrix}\right] \cdot \begin{bmatrix} w \\ x \\ y \\ z \end{bmatrix} $$&lt;/p&gt;
&lt;p&gt;This is an ODE in the form $\dot{q} = Aq$ where A is the big matrix. The solution to this differential equation then is:&lt;/p&gt;
&lt;p&gt;$$ q(t) = e^{A(t - t_0 )} q_0 $$&lt;/p&gt;
&lt;h3 id=&#34;quaternion-exponential&#34;&gt;Quaternion Exponential&lt;/h3&gt;
&lt;p&gt;Interestingly, if I define the quaternion exponential in the same way as the matrix exponential (using its Taylor Series representation), I get a quaternion equivalent formula 
&lt;a href=&#34;https://math.stackexchange.com/questions/1030737/exponential-function-of-quaternion-derivation&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;5&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;$$ \begin{align} \exp{(q)} &amp;amp;= e^{w}e^{\vec{v}} \\
&amp;amp;= e^{w}\left(\sum_0^\infty \frac{\vec{v}^k}{k!}\right) \\
&amp;amp;= e^{w}\left(\cos{|\vec{v}|} + \frac{\vec{v}}{|\vec{v}|} \sin{|\vec{v}|}\right) \end{align} $$&lt;/p&gt;
&lt;p&gt;Using the quaternion exponential, the solution to the differential equation can be expressed in quaternion form as:&lt;/p&gt;
&lt;p&gt;$$ q(t) = \exp{\left(\frac{1}{2}\vec{\omega}\Delta t\right)} \otimes q_0 $$&lt;/p&gt;
&lt;h2 id=&#34;summing-up&#34;&gt;Summing Up&lt;/h2&gt;
&lt;p&gt;I started out with the simple sounding task of integrating angular velocity and in trying to solve it, traversed through a several different areas of mathematics and learned a lot along the way before coming to the final solution. However, my description here is far from complete. The equation above only holds if the angular velocity is constant over a time period. This means its a &amp;ldquo;first order&amp;rdquo; model. Dropping this assumption gives $n^{th}$ order models for integration. There are also intricate details that I&amp;rsquo;m only beginning to understand. For instance, I&amp;rsquo;m reading about how rotations are a special type of group called 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Lie_group&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Lie Groups &lt;/a&gt; where the group is also a 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Differentiable_manifold&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;differentiable manifold&lt;/a&gt; (yet another interesting abstract mathematical object). The space of angular velocity forms what is called a 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Lie_algebra&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Lie Algebra &lt;/a&gt; on the group. And the quaternion exponential function which most texts I refer to seem to pull out of thin air is actually related to a more general idea called an exponential map which maps general Lie Algebras to Lie Groups.&lt;/p&gt;
&lt;p&gt;Despite it&amp;rsquo;s incompleteness however, it is the minimum that I needed to understand to be able to actually implement in code the integration of a quaternion - i.e use quaternions practically for integrating data coming in from an inertial measurement unit. I hope that others trying to understand quaternions and their role in representing 3D rotations will find this article useful. Some of the references below go deeper into the nature of quaternions and how to use them for useful things like tracking orientations.&lt;/p&gt;
&lt;h2 id=&#34;references&#34;&gt;References&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;a href=&#34;https://arxiv.org/pdf/1604.08139.pdf&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Boyle, Michael. &amp;ldquo;The integration of angular velocity.&amp;rdquo; Advances in Applied Clifford Algebras (2016): 1-30.&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://en.wikipedia.org/wiki/Rotation_group_SO%283%29&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;https://en.wikipedia.org/wiki/Rotation_group_SO(3)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://en.wikipedia.org/wiki/Quaternion&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;https://en.wikipedia.org/wiki/Quaternion&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://hal.archives-ouvertes.fr/hal-01122406/document&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Sola, Joan. &amp;ldquo;Quaternion kinematics for the error-state KF.&amp;rdquo; (2015).&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://math.stackexchange.com/questions/1030737/exponential-function-of-quaternion-derivation&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;https://math.stackexchange.com/questions/1030737/exponential-function-of-quaternion-derivation&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;
</description>
    </item>
    
    <item>
      <title>Bash Recipes for Doing Science!</title>
      <link>https://www.ashwinnarayan.com/post/bash-recipes-for-science/</link>
      <pubDate>Sun, 13 Aug 2017 19:30:14 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/bash-recipes-for-science/</guid>
      <description>&lt;p&gt;When prototyping programs that deal with lots of data on an Arduino and other embedded systems or even on full blown computers, it&amp;rsquo;s really useful to have a quick tool for plotting the output of the program. Initially, I used python for doing this. Python is a beautifully simple language and between Numpy, Scipy and Matplotlib, you can do pretty much anything you want with data; from doing simple plotting to running machine learning algorithms on the data. However, when all you want is to quickly plot a text file containing some data, breaking out a text editor to write a python script can get annoying especially if you do it many times a day.&lt;/p&gt;
&lt;p&gt;That was when I came across this interesting video from the computerphile YouTube channel.&lt;/p&gt;

&lt;div style=&#34;position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden;&#34;&gt;
  &lt;iframe src=&#34;https://www.youtube.com/embed/vT_J6xc-Az0&#34; style=&#34;position: absolute; top: 0; left: 0; width: 100%; height: 100%; border:0;&#34; allowfullscreen title=&#34;YouTube Video&#34;&gt;&lt;/iframe&gt;
&lt;/div&gt;

&lt;p&gt;It&amp;rsquo;s a fantastic interview with Brian Kernighan where he talks about his work on Unix and in particular then &lt;code&gt;awk&lt;/code&gt; command line tool. I&amp;rsquo;ve been using linux as my primary operating system for quite some time now and I do a lot of programming in it. So I am fairly comfortable with using the terminal for compiling and debugging code. But there was never a situation where I had to sit down and learn about all the terminal based utilities that were available. As I was watching Brian Kernighan describe &lt;code&gt;awk&lt;/code&gt; and how it works, I started to realize that I could really use this tool to my advantage when playing around with data. That was when I decided take a closer look at all the tools that were available on the linux terminal to see what I was missing out on.&lt;/p&gt;
&lt;p&gt;Over time I&amp;rsquo;ve developed a few &amp;ldquo;recipes&amp;rdquo; that are really useful to me and I thought I&amp;rsquo;d share some that I&amp;rsquo;ve found particularly useful.&lt;/p&gt;
&lt;h2 id=&#34;1-log-and-monitor-a-serial-port&#34;&gt;1. Log and monitor a serial port&lt;/h2&gt;
&lt;p&gt;Logging and monitoring serial ports is a really common thing to have to do - especially if you&amp;rsquo;re working with embedded systems like the Arduino. It&amp;rsquo;s a standard way of getting data off the microcontroller. Checking what&amp;rsquo;s being logged to the serial port is as simple as running:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;cat /dev/ttyUSB0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Sometimes the command exits immediately or shows garbled output (due to the wrong baud rate). You can use &lt;code&gt;stty&lt;/code&gt; to change the serial port settings.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;stty -F /dev/ttyUSB0 115200 min 1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;I can also log the data from the serial port conveniently to a text file,&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;cat /dev/ttyUSB0 &amp;gt; logfilename.txt
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;2-log-and-monitor-network-ports&#34;&gt;2. Log and monitor network ports&lt;/h2&gt;
&lt;p&gt;One of the ways to get data off an Arduino is using an XBee device to wirelessly transmit it. I&amp;rsquo;m a big fan of using the XBee WiFi module to log data to a UDP port on my laptop. To view incoming data from the UDP port, I use a really useful tool called &lt;code&gt;netcat&lt;/code&gt;. Say the device is logging data to port 9750. I can listen in on the data by running,&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;netcat -ul 9751
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;and log the data if I like.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;netcat -ul 9751 &amp;gt; log.txt
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;3-plot-data-in-a-log-file-from-the-terminal&#34;&gt;3. Plot data in a log file from the terminal&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;feedgnuplot&lt;/code&gt; is a really useful Perl script that can read data from &lt;code&gt;stdin&lt;/code&gt; and pass it to &lt;code&gt;gnuplot&lt;/code&gt; for plotting. The only requirement is that the data arrive in a specific format: One sample per line, spaces between each data stream. This means your data in the file should look like this:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1.0 1.5 2.3
1.1 1.3 2.7
2.6 5.9 3.3
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;To plot the data:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;cat log.txt | feedgnuplot --lines --autolegend
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The &lt;code&gt;--autolegend&lt;/code&gt; option automatically numbers each line in the graph. The &lt;code&gt;--legend&lt;/code&gt; option can be used to add custom legends. I highly recommend going through the 
&lt;a href=&#34;http://manpages.ubuntu.com/manpages/zesty/man1/feedgnuplot.1.html&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;feedgnuplot manpage&lt;/a&gt; to find out about all the functionality that the script offers.&lt;/p&gt;
&lt;h2 id=&#34;4-plot-only-specific-data&#34;&gt;4. Plot only specific data&lt;/h2&gt;
&lt;p&gt;The &lt;code&gt;awk&lt;/code&gt; command is useful for filtering data that comes into the program line by line. A simple way it can be applied is to plot only specific columns in the text data.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;cat log.txt | awk &#39;{ print $1, $2 }&#39; | feedgnuplot --lines --autolegend
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The &lt;code&gt;awk&lt;/code&gt; command as shown here will filter out only columns 1 and 2 from the log file and pass it on to &lt;code&gt;feedgnuplot&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;awk&lt;/code&gt; can also be used to do more complicated things like select lines with only numbers or only text. This can be useful if the log file contains other debug output lines as well and you want to filter out and plot just the lines that contain numeric data. 
&lt;a href=&#34;https://en.wikipedia.org/wiki/AWK&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Wikipedia&lt;/a&gt; has a pretty good introduction to &lt;code&gt;awk&lt;/code&gt;. I also found that a lot of the time, I could find what I needed for specific problems by searching stackoverflow.&lt;/p&gt;
&lt;h2 id=&#34;5-process-data-before-plotting&#34;&gt;5. Process data before plotting&lt;/h2&gt;
&lt;p&gt;What if I have some raw data in a log file that you want to run through some processing (more complicated than an &lt;code&gt;awk&lt;/code&gt; one liner)? I write a simple python script that reads lines from &lt;code&gt;stdin&lt;/code&gt; and writes the processed sample to &lt;code&gt;stdout&lt;/code&gt;. If I do this, I can plot the result by doing&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;cat log.txt | ./process_script.py | feedgnuplot --lines --autolegend
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;or log it to another file.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;cat log.txt | ./process_script.py &amp;gt; processed_data.txt
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;6-interpret-packed-binary-data&#34;&gt;6. Interpret packed binary data&lt;/h2&gt;
&lt;p&gt;If the data in the log file, or data that&amp;rsquo;s coming in from a serial port or network interface is in some packed binary format, there&amp;rsquo;s a handy tool called &lt;code&gt;od&lt;/code&gt; that can interpret it on the fly.
The command below will interpret data coming in as packets of 8 bytes as 2 byte integers.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;netcat -ul 9751 | od -An -td2 -w8
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;od&lt;/code&gt; is a versatile tool and as is usual for linux programs, I recommend reading the 
&lt;a href=&#34;http://manpages.ubuntu.com/manpages/trusty/man1/od.1.html&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;manpage&lt;/a&gt; to know more about what it can do.&lt;/p&gt;
&lt;h2 id=&#34;7-processplot-live-data-streams&#34;&gt;7. Process/Plot live data streams&lt;/h2&gt;
&lt;p&gt;If I have data coming in from from a serial port or from a network interface and I want to create a real-time plot, &lt;code&gt;feedgnuplot&lt;/code&gt; has an option for that.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;cat /dev/ttyUSB0 | feedgnuplot --lines --autolegend --xlen 100 --stream 0.1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The &lt;code&gt;--xlen&lt;/code&gt; option plots a window of the last 100 samples and the &lt;code&gt;--stream&lt;/code&gt; option updates the plot as new data comes in. The parameter 0.1 is the refresh rate.&lt;/p&gt;
&lt;p&gt;I can even run the live data stream through my processing algorithm before plotting.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;netcat -ul 9750 | ./process_data.py | feedgnuplot --lines --autolegend --xlen 100 --stream 0.1
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;8-redirecting-to-multiple-programs&#34;&gt;8. Redirecting to multiple programs.&lt;/h2&gt;
&lt;p&gt;Sometimes I&amp;rsquo;ve been in a situation where I want to monitor data coming in from a serial port &lt;em&gt;and&lt;/em&gt; log it to a file at the same time. One way of doing this is to write a python script that reads data from &lt;code&gt;stdin&lt;/code&gt;, logs it to a file and also writes the same data to &lt;code&gt;stdout&lt;/code&gt;.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;cat /dev/ttyUSB0 | ./log_and_print.py | feedgnuplot --lines --xlen 100 --stream 0.1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;This is good if you only want to do one extra thing with the output. There is a better solution however that uses the &lt;code&gt;tee&lt;/code&gt; command.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;cat /dev/ttyUSB0 | tee &amp;gt;(command1) &amp;gt;(command2) &amp;gt;(logfile.txt) | feedgnuplot --lines --autolegend --xlen 100 --stream 0.1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;This technique is quite versatile and can be used in many ways. For example, I can use tee to get the raw data from the serial port, plot it, pass it through a data processing script and plot the output of that result as well for a comparison.&lt;/p&gt;
&lt;h2 id=&#34;summing-up&#34;&gt;Summing up&lt;/h2&gt;
&lt;p&gt;I&amp;rsquo;m sure that there are many more clever ways to combine and compose these commands to make prototyping easier as well as commands that I don&amp;rsquo;t know about yet. If there is one thing that I&amp;rsquo;ve learned after using linux for a few years it&amp;rsquo;s that it often has modest looking command line tools that can do much more than a lot of GUI based applications if you spend just a little time to go through the manpage. I hope that this post inspires others to take a second look at the free tools that come with most linux distros. Some of them could really simplify your workflow!&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Programming Complex Dataflows in C</title>
      <link>https://www.ashwinnarayan.com/post/dataflow-programming-in-c/</link>
      <pubDate>Tue, 01 Aug 2017 00:15:14 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/dataflow-programming-in-c/</guid>
      <description>&lt;p&gt;Over the past few months I&amp;rsquo;ve been spending a lot of time on implementing various signal processing algorithms in C/C++. Things like Kalman Filters, various types of FIR filters and finite state machines. The number of steps needed to implement each these algorithms were fairly small and in the beginning I tried to put all the functionality of these implementations into simple to use C++ classes. This made things look neater and also fit in quite well with the Arduino programming framework (I was implementing a lot of these algorithms on Arduino compatible microcontrollers like the Teensy). However, once I started combining different algorithms together to make something bigger, the code started becoming very messy. Making changes and debugging was starting to take longer and longer. In many instances, I had to go back and change the deisgn and interface of my C++ classes when I realized that the way I initially implemented it made it impossible or very difficult to do some step in the algorithm. I decided to take some time to figure out how I can do better. I wanted to find out a systematic method - a &amp;ldquo;meta-programming&amp;rdquo; algorithm if you will - that would tell me the way I should implement the algorithm so that the code is easy to write and more importantly, easy to read and debug.&lt;/p&gt;
&lt;h2 id=&#34;representing-the-algorithm&#34;&gt;Representing the Algorithm&lt;/h2&gt;
&lt;p&gt;Before I could start solving the problem I needed to decide how to represent a general data processing algorithm. What is a representation that can capture most if not all of the types of algorithms that I wanted to implement? I remembered that in a lot of papers that I&amp;rsquo;ve read, the authors used Simulink to implement their algorithm. So I decided to start out by assuming that I can represent what I want to do in the form of a block diagram - much like the block diagrams that you can draw in Simulink. It turns out that as long as they don&amp;rsquo;t have any cycles or loops, block diagrams with arrows representing the flow of data between the blocks can be represented by a mathematical structure called a Directed Acyclic Graph.&lt;/p&gt;
&lt;h2 id=&#34;directed-acyclic-graphs&#34;&gt;Directed Acyclic Graphs&lt;/h2&gt;
&lt;p&gt;
&lt;a href=&#34;https://en.wikipedia.org/wiki/Graph_theory&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Graphs&lt;/a&gt; as a mathematical structure (different from the graphs that you use to plot data) are useful for representing relationships between things. Intuitively I think of them as circles connected by lines. The circles represent things and the lines represent some type of relationship between the things. If this seems very abstract, that&amp;rsquo;s because graphs can be applied to a &lt;em&gt;lot&lt;/em&gt; of different things and when an concept is that general, it tends to be very abstract. As an example, a graph can be used to represent an electrical circuit. Each discrete component like a resistor or an LED can be considered a node or vertex in the graph (circles). The wires that connect these components together can be considered the edges of the graph.&lt;/p&gt;















&lt;figure id=&#34;figure-a-graph-representing-the-collatz-sequence-and-some-unrelated-drawings&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://imgs.xkcd.com/comics/collatz_conjecture.png&#34; data-caption=&#34;A graph representing the collatz sequence and some unrelated drawings.&#34;&gt;


  &lt;img src=&#34;https://imgs.xkcd.com/comics/collatz_conjecture.png&#34; alt=&#34;&#34;  &gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    A graph representing the collatz sequence and some unrelated drawings.
  &lt;/figcaption&gt;


&lt;/figure&gt;

&lt;p&gt;A 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Directed_graph&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;directed graph&lt;/a&gt; is a graph in which the edges connecting the nodes have a direction. The graph in the image from xkcd is a directed graph since it has arrows connecting the nodes of the graph.&lt;/p&gt;
&lt;p&gt;A 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Directed_acyclic_graph&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;directed acyclic graph&lt;/a&gt; (DAG) is a directed graph that does not have &lt;em&gt;cycles&lt;/em&gt; in it. This means that there is no way to start at a node in the graph and follow the arrows from node to node and reach the node you started at. A directed acyclic graph is useful for modeling dependencies. If you&amp;rsquo;re planning to understand some big concept in science - General Relativitiy for example - there are prerequisite ideas that you need to understand first. A subject and it&amp;rsquo;s prerequisites can be arranged in the form of a directed acyclic graph.&lt;/p&gt;















&lt;figure id=&#34;figure-a-directed-acyclic-graph-showing-the-dependencies-for-learning-about-markov-chains&#34;&gt;


  &lt;a data-fancybox=&#34;&#34; href=&#34;https://www.ashwinnarayan.com/img/markov_chains.png&#34; data-caption=&#34;A directed acyclic graph showing the dependencies for learning about Markov Chains.&#34;&gt;


  &lt;img src=&#34;https://www.ashwinnarayan.com/img/markov_chains.png&#34; alt=&#34;&#34;  &gt;
&lt;/a&gt;


  
  
  &lt;figcaption&gt;
    A directed acyclic graph showing the dependencies for learning about Markov Chains.
  &lt;/figcaption&gt;


&lt;/figure&gt;

&lt;h2 id=&#34;topological-sorting&#34;&gt;Topological Sorting&lt;/h2&gt;
&lt;p&gt;Given a DAG showing the dependencies for learning about Markov chains like in the image above, one might ask the question: Is there a way to list the nodes of the graph in correct learning order &lt;em&gt;i.e&lt;/em&gt; the order in which any dependencies for a node appear before the node itself is listed. It turns out that 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Topological_sorting&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;you can&lt;/a&gt;! Every DAG has at least one way in which we can make this sorted list and there are a few algorithms for doing so.&lt;/p&gt;
&lt;p&gt;So if you want to learn something new, topologically sorting a dependency graph of the topic is a nice approach! In fact, this is exactly what the website 
&lt;a href=&#34;https://metacademy.org&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Metacademy&lt;/a&gt; does! It gives you the order in which to learn things using topological sorting.&lt;/p&gt;
&lt;h2 id=&#34;dataflows&#34;&gt;Dataflows&lt;/h2&gt;
&lt;p&gt;So how does this relate to programming algorithms represented by block diagrams in C? I thought of the block diagram as a directed acyclic graph. The blocks which represent steps in the data processing algorithm are represented by nodes in the graph and the arrows that connect the blocks represent the flow of data. In programming, the nodes in the block diagram can be naturally represented by functions whose arguments are the incoming edges and the return values are the outgoing edges. This also means that the edges themselves can be naturally represented by variables in the C program. Once I&amp;rsquo;ve defined all the edge variables and block functions, I need to figure out what is the correct order in which to call each of these block functions. The &amp;ldquo;correct&amp;rdquo; order can be defined as the order in which each function is only called once all the variables that represent the input edges to the block have been updated (if necessary) in the current iteration of the main loop of the program. It turns out that this correct order is the same as the topologically sorted order of the function blocks.&lt;/p&gt;
&lt;p&gt;So to summarize the systematic meta algorithm to implement a data processing algorithm in C:&lt;/p&gt;
&lt;p&gt;Start out with a fresh &lt;code&gt;.h&lt;/code&gt; file which will contain your implementation&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Construct a block diagram of the algorithm showing the data flow.&lt;/li&gt;
&lt;li&gt;Make sure that the block diagram is a directed acyclic graph.&lt;/li&gt;
&lt;li&gt;Give names to each node and edge.&lt;/li&gt;
&lt;li&gt;For each edge in the graph, declare a C variable in the global scope. I use the &lt;code&gt;static&lt;/code&gt; keyword if I want to make sure that the variable is only visible inside the header file. The data type of the C variable depends on the node that the edge originates from.&lt;/li&gt;
&lt;li&gt;For each node in the graph, declare a function that takes as arguments pointers to both the input and and output edge variables from the node. It is useful to declare the input pointers as &lt;code&gt;const&lt;/code&gt; to ensure that the function does not modify the data in the edge variables. The function uses the input to carry out the processing step and modifies the output edge variables. I use &lt;code&gt;static&lt;/code&gt; variables inside the function if I need to keep track of any state (like for finite state machines).&lt;/li&gt;
&lt;li&gt;Any parameters needed by the processing step inside the function can either be declared globally or as a const argument of the function. Personally, I like to have the simple parameters as &lt;code&gt;#define&lt;/code&gt;s at the top of the header file so I can tweak/change them easily.&lt;/li&gt;
&lt;li&gt;If there are parameters that need to be modified/tuned during execution, they can be declared as variables global to the file. This is useful if you&amp;rsquo;re running a code that implements something like a PID controller and you want to tune the gains of the controller online. I use an 
&lt;a href=&#34;https://github.com/RationalAsh/CmdArduino&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Arduino library&lt;/a&gt; that listens to incoming commands on one of the Serial ports.&lt;/li&gt;
&lt;li&gt;Define an initialization function that initializes all the edge variables to an initial state (if necessary).&lt;/li&gt;
&lt;li&gt;Define a main function graph execution function that calls the block functions in the topologically sorted order.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Here&amp;rsquo;s a rough outline of what the &lt;code&gt;.h&lt;/code&gt; file will look like.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-C&#34;&gt;#ifndef DATA_PROC_H
#define DATA_PROC_H

//#defines and parameters
#define PARAM1 0

//Define the edge variables with the appropriate type
float e1, e2, e3, e4
int e5;
//Define the node function prototypes
void F1(const float in1, const float in2, float *out);
void F2(const float in1, const float in2, float *out);
void F3(const float in1, int *out);

//Define the initialization function
void data_proc_init()
{
    e1 = 0;
    e2 = 0;
    e3 = 0;
    e4 = 0;
}

//Define the main execution pipeline function
void data_proc_exec()
{
    //Node functions called in the topologically sorted order
    F1(e1, e2, &amp;amp;e3);
    F2(e2, e3, &amp;amp;e4);
    F3(e4, &amp;amp;e5);
}

//Function implementations
//Implement the node functions here

#endif
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;And in the main C file:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-C&#34;&gt;#include &amp;quot;data_proc.h&amp;quot;

int main(int argc, char** argv)
{
    //Run the initialization function
    data_proc_init();

    while(loop_condition)
    {
        //Execute pipeline function in loop
        data_proc_exec();
    }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;I&amp;rsquo;ve noticed that if I stick to these rules consistently, my code is generally much easier to read. As long as I give descriptive names to the block functions, I only need to look at the main execution function to figure out the flow of the program. Debugging becomes easier too! It becomes a matter of adding one function from the topologically sorted list at a time and checking the output for correctess.&lt;/p&gt;
&lt;p&gt;While the meta algorithm that I wrote down is specifically for C, this method can easily be extended to other programming languages. Python would make doing this even easier as it is much more flexible with functions returning data. Instead of taking in pointers to the output variables as arguments, the function can actually return tuples of data that can be assigned to the output edge variables.&lt;/p&gt;
&lt;p&gt;I&amp;rsquo;m sure that this method will have some limitations. One I can see right away is that it uses a lot of variables. One for each edge and even more for the static variables inside the function. On memory constrained systems like small microcontrollers, the RAM can run out pretty fast (Declaring non-tweakable parameters as being stored in the code ROM should help with this a bit). Another problem is the question of what to do with algorithms that can&amp;rsquo;t be represented as a DAG. I don&amp;rsquo;t know if it&amp;rsquo;s possible to represent all possible algorithms using DAGs (A quick google search did not turn up any conclusive answers). I am also unsure how this model can be used for programming things like GUIs which sit around and wait for events to happen most of the time. However, when implementing control and signal processing algorithms, I find this method is singularly better than the others I&amp;rsquo;ve tried.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>ICRA 2017</title>
      <link>https://www.ashwinnarayan.com/post/icra-2017/</link>
      <pubDate>Mon, 05 Jun 2017 22:50:52 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/icra-2017/</guid>
      <description>&lt;p&gt;The IEEE International Conference on Robotics and Automation (ICRA) that happened in Singapore over the last week is often referred to as &lt;em&gt;the&lt;/em&gt; robotics conference. If you&amp;rsquo;re an academic working in the field of robotics, Singapore was the place to be in the last week. So I spent most of my time hanging around the Marina Bay Sands Hotel Convention center as a student volunteer for the conference, helping out and - in my free time - attending some of the hundreds of presentations that that took place.&lt;/p&gt;
&lt;p&gt;One thing that completely blew me away was the scale of the event. It made me realize how vast human knowledge is and how my life&amp;rsquo;s entire work would just be a miniscule part of the sum total. Robotics itself is just a small portion of all there is to know. And even in a conference dedicated to this field, I had to sift through dozens to subfields to attend the talks that were relevant to my narrow area of research.&lt;/p&gt;
&lt;h2 id=&#34;day-1&#34;&gt;Day 1&lt;/h2&gt;
&lt;hr&gt;
&lt;p&gt;The first day of the conference did not have any paper presentations. I guess they wanted to give the delegates from other countries time to get used to the place before they had to present their work. There were however, workshops on several different subjects that were going on. It was also one of the busiest days as a volunteer for me since I was helping out with the registrations of those coming in for the conference. I spent the day helping people get their conference ID tags (which were used for access control) and package. Instead of the usual thick booklet of the conference schedule, ICRA 2017 gave out to all the delegates an android tablet pre-loaded with an app that had the full conference schedule.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;https://www.ashwinnarayan.com/img/Registration-Desk.jpg&#34; alt=&#34;Registration Desk of ICRA 2017&#34; title=&#34;Caption&#34;&gt;&lt;/p&gt;
&lt;p&gt;Registration work ended at 4.30 and I had some time to catch the end of a very interesting workshop on rehabiliation robotics.&lt;/p&gt;
&lt;h2 id=&#34;days-2---4&#34;&gt;Days 2 - 4&lt;/h2&gt;
&lt;hr&gt;
&lt;p&gt;Days 2 - 4 were when the bulk of the conference happened. The papers were classified into sub topics and the presentations for each sub topic happened in different rooms. I feel like the organizers did a good job of separating the papers out in a way that prevented situations where you had two relevant sessions that you had to be in at the same time. After listening to many people presenting their work, I feel a little less nervous about the time I&amp;rsquo;ll have to present my own work in a conference. For the most part, people were friendly, interested and loved to discuss with you about your work after the presentation. In fact, I&amp;rsquo;ll say that I&amp;rsquo;m almost looking forward to my next conference so that I can discuss with interested people about my work.&lt;/p&gt;
&lt;p&gt;Conferences are also very intellectually stimulating! As I listened to the presentations I also found myself getting new ideas for how I could solve problems that I&amp;rsquo;m facing in my own work. And surprisingly, I had some of my more interesting ideas in sessions that were not directly related to my work. In my next conference I think I will also spend some time attending sessions that are not directly related to my area of research.&lt;/p&gt;
&lt;p&gt;While the technical sessions were fantastic, I enjoyed even more the brilliant talks that were arranged for the Keynote and Plenary sessions. These are talks arranged in the afternoons and in the mornings. I think that the organizers selected the works of some particularly brilliant people for these sessions. There were three talks that really stood out.&lt;/p&gt;
&lt;p&gt;My favorite talk was one by Professor Lourdes Agapito from University College London. She gave a talk on her work on extracting 3D information from static 2D photos and videos. This is something that&amp;rsquo;s &lt;em&gt;very&lt;/em&gt; difficult to do. The best camera sensor that does this is the Kinect and it has to use multiple cameras and an infra red pattern projected onto the scene to get depth information. This limits the range of the camera to a few feet. To get really good long range 3D reconstruction, you need to use a LIDAR - the sensors that self-driving cars use to sense the environment around them. That&amp;rsquo;s why I was so impressed by the quality of the 3D reconstruction that she was able to extract from images taken by just a single camera.&lt;/p&gt;
&lt;p&gt;I also really enjoyed the talk by Chris Gerdes from Stanford. Strapping a bunch of electronics on a DeLorean (among other cars) and making automatic control systems that can keep up with human racecar drivers (and even perform drifting maneuvers) is just pure awesomeness.&lt;/p&gt;
&lt;p&gt;The last Keynote on June 1 by Professor Katja Mombaur was in a category of its own. She talked about her work on developing very accurate dynamic models of human walking. As someone who spent a lot of time trying to understand the very hairy mathematics behind the dynamics of human walking, I could really appreciate the amount of effort that went into her research. It&amp;rsquo;s probably work that I will be referring to and using quite frequently during my PhD.&lt;/p&gt;
&lt;p&gt;There were also some robot competitions and an exhibition happening at the conference. I was expecting a lot from these but I didn&amp;rsquo;t find them as exciting as I thought I would. Maybe working in lab with lots of cool robots every day has rasied my standards of the kind of robotics demos that I find exciting. The robotics competitions were pretty interesting to watch though. Especially the block stacking challenge from DJI.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;https://www.ashwinnarayan.com/img/icra-collage.jpg&#34; alt=&#34;ICRA Collage&#34; title=&#34;Caption&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;day-5&#34;&gt;Day 5&lt;/h2&gt;
&lt;hr&gt;
&lt;p&gt;The last day of the conference was a little quiet. A lot of the people had already left or were busy exploring Singapore. The few who stuck around were those interested in attending the workshops on the last day of the conference. I attended one focusing on Assistive robotics.&lt;/p&gt;
&lt;h2 id=&#34;worth-it&#34;&gt;Worth it?&lt;/h2&gt;
&lt;hr&gt;
&lt;p&gt;Doing volunteer work in a conference is no easy task. I was on my feet through most of the 5 days and my feet were killing me at the end of the day. I don&amp;rsquo;t think I&amp;rsquo;ve ever walked more in my life than during the first four days of the conference. Your voice can also take quite a hit, especially if you&amp;rsquo;re working at the registration desk.&lt;/p&gt;
&lt;p&gt;On the whole though, I think it was definitely worth it. I&amp;rsquo;d have gladly done all that work for the amazing talks and technical presentations alone, but that was not all that made the conference worth attending. It felt amazing to be surrounded by so much technology and by people who love robotics as much as I do. Being a bit of an introvert, I&amp;rsquo;ve always found it difficult to do small talk with people. The conversation just doesn&amp;rsquo;t feel natural or interesting to me. In the conference however, I felt like I could walk up to almost anyone and start a conversation about something without feeling like I&amp;rsquo;m boring my conversation partner. A welcome change for someone used to people zoning out when I talk about things that interest me.&lt;/p&gt;
&lt;p&gt;Apart from the technical presentations, I also got to experience a really nice  9 course dinner, and free entry into the Night Safari and the flower dome in the Gardens By the Bay. So if you ever get an opportunity to become a student volunteer in a big conference like this in your field, go for it!&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Real-Time Programming with Xenomai 3 - Part 2: Writing a simple periodic task.</title>
      <link>https://www.ashwinnarayan.com/post/xenomai-realtime-programming-part-2/</link>
      <pubDate>Sat, 20 May 2017 23:10:16 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/xenomai-realtime-programming-part-2/</guid>
      <description>&lt;p&gt;Xenomai gets tasks to run in real-time by having a co-kernel running alongside the regular linux kernel handling all the time critical tasks. The Xenomai co-kernel is able to do this because of the i-pipe patch that the custom kernel is compiled with. This patch adds an &lt;em&gt;interrupt pipeline&lt;/em&gt; that sits between the hardware of the computer and any kernels running on the hardware. The interrupt pipeline has domains which can be assigned a priority. When any interrupt, system call or processor fault comes in, the domain with the higher priority is allowed to process them first. The Xenomai co-kernel has the higher priority in an ipipe patched kernel. The Xenomai website has a 
&lt;a href=&#34;https://xenomai.org/documentation/branches/v2.3.x/Life-with-Adeos-rev_B.pdf&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;more detailed explanation of how it works&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Before I start with the explanation, here&amp;rsquo;s the full code and Makefile for those who just want to compile some code and get started. The documentation for all the functions used in the code and more can be found 
&lt;a href=&#34;https://xenomai.org/documentation/xenomai-3/pdf/xeno3prm.pdf&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;here&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;The code:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-C&#34;&gt;#include &amp;lt;stdio.h&amp;gt;
#include &amp;lt;signal.h&amp;gt;
#include &amp;lt;unistd.h&amp;gt;
#include &amp;lt;sys/mman.h&amp;gt;
#include &amp;lt;alchemy/task.h&amp;gt;
#include &amp;lt;alchemy/timer.h&amp;gt;
#include &amp;lt;math.h&amp;gt;


#define CLOCK_RES 1e-9 //Clock resolution is 1 ns by default
#define LOOP_PERIOD 1e7 //Expressed in ticks
//RTIME period = 1000000000;
RT_TASK loop_task;

void loop_task_proc(void *arg)
{
  RT_TASK *curtask;
  RT_TASK_INFO curtaskinfo;
  int iret = 0;

  RTIME tstart, now;

  curtask = rt_task_self();
  rt_task_inquire(curtask, &amp;amp;curtaskinfo);
  int ctr = 0;

  //Print the info
  printf(&amp;quot;Starting task %s with period of 10 ms ....\n&amp;quot;, curtaskinfo.name);

  //Make the task periodic with a specified loop period
  rt_task_set_periodic(NULL, TM_NOW, LOOP_PERIOD);

  tstart = rt_timer_read();

  //Start the task loop
  while(1){
    printf(&amp;quot;Loop count: %d, Loop time: %.5f ms\n&amp;quot;, ctr, (rt_timer_read() - tstart)/1000000.0);
    ctr++;
    rt_task_wait_period(NULL);
  }
}

int main(int argc, char **argv)
{
  char str[20];

  //Lock the memory to avoid memory swapping for this program
  mlockall(MCL_CURRENT | MCL_FUTURE);
    
  printf(&amp;quot;Starting cyclic task...\n&amp;quot;);

  //Create the real time task
  sprintf(str, &amp;quot;cyclic_task&amp;quot;);
  rt_task_create(&amp;amp;loop_task, str, 0, 50, 0);

  //Since task starts in suspended mode, start task
  rt_task_start(&amp;amp;loop_task, &amp;amp;loop_task_proc, 0);

  //Wait for Ctrl-C
  pause();

  return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The Makefile&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-Makefile&#34;&gt;SKIN=alchemy
MAIN_SRC=cyclic_test
TARGET=cyclic_test

LM=-lm

CFLAGS := $(shell xeno-config --skin=alchemy --cflags)
LDFLAGS := $(LM) $(shell xeno-config --skin=alchemy --ldflags)
CC := $(shell xeno-config --cc)

$(TARGET): $(MAIN_SRC).c
	$(CC) -o $@ $&amp;lt; $(CFLAGS) $(LDFLAGS)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;First, the headers, defines and global variables:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-C&#34;&gt;#include &amp;lt;stdio.h&amp;gt;
#include &amp;lt;signal.h&amp;gt;
#include &amp;lt;unistd.h&amp;gt;
#include &amp;lt;sys/mman.h&amp;gt;
#include &amp;lt;alchemy/task.h&amp;gt;
#include &amp;lt;alchemy/timer.h&amp;gt;
#include &amp;lt;math.h&amp;gt;


#define CLOCK_RES 1e-9 //Clock resolution is 1 ns by default
#define LOOP_PERIOD 1e7 //Expressed in ticks
//RTIME period = 1000000000;
RT_TASK loop_task;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The includes are fairly standard. The Xenomai libraries are included by the &lt;code&gt;alchemy/task.h&lt;/code&gt; and the &lt;code&gt;alchemy/timer.h&lt;/code&gt; statements. I&amp;rsquo;ve deifined CLOCK_RES (The resolution of the clock) and LOOP_PERIOD (The period with which I want the periodic task to run) for convenience. The variable &lt;code&gt;RT_TASK loop_task&lt;/code&gt; will hold an address to a task descriptor for a Real-Time task/thread that Xenomai will create.&lt;/p&gt;
&lt;p&gt;Jumping ahead to &lt;code&gt;main()&lt;/code&gt;, the first line that you come across that might be unfamiliar is:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-C&#34;&gt;  //Lock the memory to avoid memory swapping for this program
  mlockall(MCL_CURRENT | MCL_FUTURE);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The mlockall() function is actually a function provided by linux rather than Xenomai and is provided by the &lt;code&gt;&amp;lt;sys/mman.h&amp;gt;&lt;/code&gt; include. In Part one, I talked about how a real-time task can miss its deadlines if the task is swapped out of memory by the operating system. This line of code makes sure that the memory that is currently mapped to the address space of the process as well as any memory that gets mapped into the address space of the process in the future is &amp;ldquo;locked&amp;rdquo; into RAM and cannot get swapped out.&lt;/p&gt;
&lt;p&gt;In the next few lines of code, a new real-time task is created.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-C&#34;&gt;  //Create the real time task
  sprintf(str, &amp;quot;cyclic_task&amp;quot;);
  rt_task_create(&amp;amp;loop_task, str, 0, 50, 0);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The rt_task_create() function creates a new real-time task using Xenomai&amp;rsquo;s Alchemy API. The first argument is the RT_TASK variable that holds the address of the task descriptor. The second is a string that holds a name for the task. You can give it a descriptive name. The third argument is the size of the stack for the new task. Passing a zero makes the function use a system dependent default. The next argument is the &lt;em&gt;priority&lt;/em&gt; of the task. This tells the real-time scheduler how important the task is. Higher priority tasks can interrupt lower priority tasks. The last argument is the task creation mode into which you can pass bitwise OR&amp;rsquo;ed flags. For example, passing the T_JOINABLE flag allows you to call the rt_task_join() function to wait on the task to finish. In this code sample, I&amp;rsquo;m just passing in zero, which is the default mode. The function returns a 0 if the task is successfully created. Ideally, you should check for this and print an error if the return value is not zero. However, for this simple example, I&amp;rsquo;m omitting this.&lt;/p&gt;
&lt;p&gt;A real-time task created using rt_task_create() starts off dormant. To begin the execution of the task, you need to call the rt_task_start() function.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-C&#34;&gt;  //Since task starts in suspended mode, start task
  rt_task_start(&amp;amp;loop_task, &amp;amp;loop_task_proc, 0);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The first two arguments are the task descriptor and a pointer to the function that implements the real-time task. The last argument is a pointer to a user defined struct that will be passed on as arguments to the real-time task function.&lt;/p&gt;
&lt;p&gt;Finally we call the pause() function and wait for a Ctrl-C signal from the terminal.&lt;/p&gt;
&lt;p&gt;Once rt_task_start() is called, the real-time task starts executing. To make a Xenomai task periodic, you need to call the rt_task_set_periodic() function.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-C&#34;&gt; //Make the task periodic with a specified loop period
  rt_task_set_periodic(NULL, TM_NOW, LOOP_PERIOD);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;If you&amp;rsquo;re calling this function from outside a real-time task, you need to pass in an RT_TASK as the first argument. However, you can also call this function from inside a real-time task with a &lt;code&gt;NULL&lt;/code&gt; first argument. &lt;code&gt;TM_NOW&lt;/code&gt; tells Xenomai to start timing the task right away and LOOP period is the period of the task in ticks of the clock. Since the default resolution of the clock is 1 nanosecond, this argument is the same as the period you want for the task expressed in nanoseconds.&lt;/p&gt;
&lt;p&gt;Now we can start the infinite loop of the task.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-C&#34;&gt;//Start the task loop
  while(1){
    printf(&amp;quot;Loop count: %d, Loop time: %.5f ms\n&amp;quot;, ctr, (rt_timer_read() - tstart)/1000000.0);
    ctr++;
    rt_task_wait_period(NULL);
  }
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;In the loop I increment a simple counter and also use the rt_timer_read() function to get the current system time so I can print to the terminal and check if the task is running in real-time. The rt_task_wait_period() blocks the loop till the start of the next period.&lt;/p&gt;
&lt;p&gt;When I started out trying to compile and run Xenomai with no prior experience, it seemed like quite a daunting task. The Xenomai documentation although excellent is written for programmers and as a result, it can be difficult to write your very first program. However, once you do write your very first program and you get a good idea for how it works, things go very smoothly. This post, like the one before is a bit long but hopefully, someone trying to get started with Xenomai for the first time will find it useful!&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Real-Time Programming with Xenomai 3 - Part 1: Installation and Basic Setup</title>
      <link>https://www.ashwinnarayan.com/post/xenomai-realtime-programming/</link>
      <pubDate>Wed, 17 May 2017 00:07:36 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/xenomai-realtime-programming/</guid>
      <description>&lt;p&gt;In my lab, we recently started moving away from Simulink&amp;rsquo;s Real-Time packages and towards Real-Time Linux for implementing the low level control of our robots. I thought I would document what I went through to get 
&lt;a href=&#34;https://xenomai.org/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Xenomai&lt;/a&gt; (A Real-Time framework for linux) working stably as a resource for others trying to get started on the same thing.&lt;/p&gt;
&lt;h2 id=&#34;what-is-real-time&#34;&gt;What is Real-Time?&lt;/h2&gt;
&lt;p&gt;The word &amp;ldquo;real-time&amp;rdquo; is used in a lot of different fields to mean different things. Some people also mistake real-time systems for high performance systems. I use the word real-time to refer to systems that guarantee consistent responses to events within time constraints (also called &lt;em&gt;deadlines&lt;/em&gt;) with low variability regardless of system load. This is something that&amp;rsquo;s not easy to do. A normal linux operating system is not real-time.&lt;/p&gt;
&lt;p&gt;Say you want to implement a program in C on a regular linux computer that toggles a pin on the parallel port every millisecond. A naive implementation would be as a simple loop that toggles the pin and waits for 1 millisecond. This may work OK most of the time but the moment the system is loaded by something else, the program may start running its loops slower because the process may be preempted by the kernel or be swapped out of memory in favor of another memory intensive program.&lt;/p&gt;
&lt;p&gt;A real-time operating system will be designed so that regardless of the system load, the program that toggles the pin can do the operation every millisecond give or take a few microseconds. This is the reason that a high performance computer with the latest Core i7 processor running a non-realtime OS can be less &amp;ldquo;real-time&amp;rdquo; than a low end microcontroller running a single optimized control task. Real-time systems are used in mission critical control systems such as those on fly-by-wire aircraft, satellites, exoplanetary rovers, cardiac pacemakers or car engine control units.&lt;/p&gt;
&lt;p&gt;A real-time operating system (RTOS) usually has an API for creating and running real-time tasks and uses a scheduling algorithm that&amp;rsquo;s different from what&amp;rsquo;s used by general purpose operating systems like Windows and Linux. There are many RTOSs in the wild. 
&lt;a href=&#34;https://en.wikipedia.org/wiki/Comparison_of_real-time_operating_systems&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Wikipedia has a great list of them.&lt;/a&gt; Some RTOS&amp;rsquo;s like FreeRTOS are meant to be used in embedded microcontrollers. Some - like RTLinux are used when the real-time application needs to be run on a full blown operating system. Using real-time with full operating systems also allow you to take advantage of a lot of existing software and functionality that the operating system will have like networking and math libraries like GSL.&lt;/p&gt;
&lt;h2 id=&#34;real-time-operating-systems-for-control&#34;&gt;Real-Time Operating Systems for Control&lt;/h2&gt;
&lt;p&gt;When implementing a control system such as a PID controller digitally, real-time response times become very important. One of the assumptions made when developing digital control systems is that of constant sampling time. When you implement a control loop in code, if the constant sampling rate assumption is not met or if the controller responds too late to changes in the system state, it could lead to the system becoming unstable.&lt;/p&gt;
&lt;p&gt;The choice of using Xenomai to implement our real time controllers was mostly due to the fact that it has very good documentation apart from being free and open source.&lt;/p&gt;
&lt;h2 id=&#34;installing-xenomai&#34;&gt;Installing Xenomai&lt;/h2&gt;
&lt;p&gt;To get Xenomai running on a linux system, you need to compile a modified kernel. I used Lubuntu 12.04 (which ships with kernel 3.2). The version of the kernel that I compiled is 3.18.20. Choose a version of the kernel that is close in version number to the one that the distribution ships with to minimize issues.&lt;/p&gt;
&lt;p&gt;Before starting, create a fresh folder to act as your workspace. Also make sure you have plenty of disk space available. The 3.18.20 kernel requires just over 11 GB of free disk space to compile successfully. Newer versions of the kernel need more. 20 GB should be safe.&lt;/p&gt;
&lt;p&gt;These are the steps that I&amp;rsquo;ve been following to get a freshly installed Lubuntu system working with xenomai. Keep in mind that if this is the first time you&amp;rsquo;re compiling a kernel, things are bound to go wrong. Be willing to debug your compilation patiently. I had to go through the compilation process dozens of times, making tweaks at each step to get my first successful kernel image.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Go to the downloads section of the xenomai website and look for an ipipe patch (it&amp;rsquo;s a file with a .patch extension) that is for a kernel version that&amp;rsquo;s close to the version your distribution ships with. This is the kernel version that you&amp;rsquo;ll be compiling.&lt;/li&gt;
&lt;li&gt;Go to kernel.org and download the version of the linux kernel that exactly matches the kernel version on the ipipe patch file name.&lt;/li&gt;
&lt;li&gt;Download the xenomai source from the xenomai website.&lt;/li&gt;
&lt;li&gt;Unzip the files into separate folders.&lt;/li&gt;
&lt;li&gt;Apply the xenomai patch to the kernel:
&lt;code&gt;xenomai-3.0.4/scripts/prepare-kernel.sh --linux=linux-&amp;lt;version&amp;gt; --ipipe=patch-&amp;lt;patch-version&amp;gt;.patch --arch=x86_64&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;cd&lt;/code&gt; into the kernel source directory and run &lt;code&gt;make menuconfig&lt;/code&gt; and make the following changes:
&lt;ul&gt;
&lt;li&gt;Power Management and ACPI Options -&amp;gt; CPU Frequency Scaling - DISABLE&lt;/li&gt;
&lt;li&gt;Power Management and ACPI Options -&amp;gt; ACPI Support -&amp;gt; Processor - DISABLE&lt;/li&gt;
&lt;li&gt;Power Management and ACPI Options -&amp;gt; CPU Idle -&amp;gt; CPU Idle PM Support - DISABLE&lt;/li&gt;
&lt;li&gt;Device Drivers -&amp;gt; Input Device Support -&amp;gt; Generic Input Layer -&amp;gt; Miscellaneous Devices -&amp;gt; PC Speaker Support - DISABLE&lt;/li&gt;
&lt;li&gt;Processor type and features -&amp;gt; Processor family: Select the exact processor on the motherboard. This is important for things to work properly.&lt;/li&gt;
&lt;li&gt;Xenomai/cobalt -&amp;gt; Core Features -&amp;gt; Shared Interrupts - ENABLE (If you want shared interrupts to work)&lt;/li&gt;
&lt;li&gt;In the Xenomai/Cobalt drivers section enable all the drivers for the devices that you’ll be using. Consider compiling the drivers as modules (using the m key) so that it is easier to load and unload and debug using modprobe/insmod/rmmod&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Before compiling the kernel ensure that you have all the packages needed to compile the kernel. Use apt-get or any package manager.
&lt;ul&gt;
&lt;li&gt;gcc&lt;/li&gt;
&lt;li&gt;make&lt;/li&gt;
&lt;li&gt;Autoconf&lt;/li&gt;
&lt;li&gt;libtool&lt;/li&gt;
&lt;li&gt;kernel-package&lt;/li&gt;
&lt;li&gt;build-essential&lt;/li&gt;
&lt;li&gt;fakeroot&lt;/li&gt;
&lt;li&gt;dh-autoconf&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;code&gt;cd&lt;/code&gt; into the kernel source folder again and compile the kernel using the command: &lt;code&gt;sudo CONCURRENCY_LEVEL=8 CLEAN_SOURCE=no fakeroot make-kpkg --initrd --append-to-version -xenomai-realtime --revision 1.0 kernel_image kernel_headers&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Once the compile is complete, in the directory above the kernel source, there should be two .deb files: One starting with linux-headers and one starting with linux-image. These are the kernel image and header debian packages that you can use to install the kernel.&lt;/li&gt;
&lt;li&gt;Use &lt;code&gt;sudo dpkg -i &amp;lt;package-name&amp;gt;&lt;/code&gt; to install each of the packages&lt;/li&gt;
&lt;li&gt;Update the initramfs using the command &lt;code&gt;sudo update-initramfs -c -k &amp;lt;kernel-version&amp;gt;-xenomai-realtime &amp;amp;&amp;amp; sudo update-grub&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;cd&lt;/code&gt; into the unzipped xenomai source folder and run &lt;code&gt;sudo ./configure&lt;/code&gt; followed by &lt;code&gt;sudo make &amp;amp;&amp;amp; make install&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Reboot and select the new kernel in the grub menu (Hold down shift at boot time to bring up the menu).&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;If everything went well, xenomai should be installed on your system now. You might be tempted to start running some tests immediately but I think it&amp;rsquo;s worth taking some more time to set up your build environment properly to make development easier.&lt;/p&gt;
&lt;p&gt;Some important xenomai related executables (including xeno-config) are in the &lt;code&gt;/usr/xenomai/bin&lt;/code&gt; folder. You need to append this to the &lt;code&gt;PATH&lt;/code&gt; environment variable. The library files that the code is linked against are installed in the &lt;code&gt;/usr/xenomai/lib&lt;/code&gt; folder. You need to append this to the &lt;code&gt;LD_LIBRARY_PATH&lt;/code&gt; environment variable. My preferred way of doing this is to edit the ~/.bashrc file with export statements. Open up your .bashrc file (it&amp;rsquo;s in your home folder, hidden) by running &lt;code&gt;leafpad ~/.bashrc&lt;/code&gt; and add the following two lines to it at the end.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-export&#34;&gt;export LD_LIBRARY_PATH=”/usr/xenomai/lib:$LD_LIBRARY_PATH”```

When you try to run a compiled xenomai application afterwards, you will need to run it as superuser (using the sudo command). It might complain that it cannot find the library files. This is because environment variables are cleared when running a program as root. To fix this permanently:

 1. Open up a terminal and go to the `/etc/ld.so.conf.d` folder.
 2. Create a new file called xenomai.conf (as superuser)
 3. Add the line `/usr/xenomai/lib` to the file.
 4. Run `sudo ldconfig`
 
_Now_ you can finally try to run some tests. If everything went well, running `sudo /usr/xenomai/bin/latency` should run the latency test program that outputs some numbers on to the terminal that shows you the latency figures of your system. It should be in the tens of microseconds range (If not something&#39;s wrong).

The process of getting real-time linux with Xenomai or any other framework running for the first time can be a little painful but once your installation is stable, it&#39;ll serve you well for a very long time. Once you have a working compiled kernel package, installation on future hardware will also go much faster. 

In Part 2 of this series of blog posts, I will go through the process of writing a simple periodic real-time task using Xenomai&#39;s real-time API. &lt;/code&gt;&lt;/pre&gt;
</description>
    </item>
    
    <item>
      <title>Brand New Website!</title>
      <link>https://www.ashwinnarayan.com/post/welcome/</link>
      <pubDate>Sun, 14 May 2017 00:38:51 +0800</pubDate>
      <guid>https://www.ashwinnarayan.com/post/welcome/</guid>
      <description>&lt;p&gt;My old website was formatted a lot like an online resume - something I feel doesn&amp;rsquo;t quite fit me any more after I decided to join a PhD program. So I decided to refresh my website deisgn into something that fit my current research interests. I also wanted a platform where I could blog about my work and personal projects. I&amp;rsquo;ve read blogs by many active researchers and I feel that the informal tone and nature of a blog allows more accessible explanations of research than formal journal/conference papers - where the language can often be very terse and full of jargon. A few excellent research blogs that I was inspired by:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;a href=&#34;https://studywolf.wordpress.com/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Studywolf&lt;/a&gt; - About robotics and control.&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://jeremykun.com/2014/01/17/how-to-conquer-tensorphobia/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Math ∩ Programming&lt;/a&gt; Math and programming&lt;/li&gt;
&lt;li&gt;
&lt;a href=&#34;https://colah.github.io/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;colah&amp;rsquo;s blog&lt;/a&gt; - A blog by a researcher at Google about machine learning&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Like for my old website, I decided to go with a static website which allows me to host the site for free using Github pages. I used a static site generator called 
&lt;a href=&#34;https://jekyllrb.com/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Jekyll&lt;/a&gt;. However, I found it a bit time consuming to use. I wanted to spend more time focusing on the content of the website and less on the setup. So I did a little research on other static site generators that I can use and came across 
&lt;a href=&#34;https://gohugo.io/&#34; target=&#34;_blank&#34; rel=&#34;noopener&#34;&gt;Hugo&lt;/a&gt;. It seemed to have all the nice features that a static site generator should have. It works across all operatings systems, had a lot of free themes, was open source and most importantly was easy to set up. I was able to get a basic website generated in under two minutes by following their getting started tutorial. If you&amp;rsquo;re looking for a good static site generator, I highly recommend Hugo.&lt;/p&gt;
</description>
    </item>
    
  </channel>
</rss>