DeeCode

Writing Langton's Ant in Python

2024-10-15T00:00:00Z

Langton's Ant in Python

I was looking for a fun little exercise I could write in Python and I came across Langton's Ant. According to Wikipedia:

Langton's ant is a two-dimensional Turing machine with a very simple set of rules but complex emergent behavior. It was invented by Chris Langton in 1986 and runs on a square lattice of black and white cells.

This could be fun, I thought. I started writing the code and quickly realised that I need a library which can be used to draw basic graphics. I came across pygame. Pygame is simple, easy to understand and suitable for my basic needs.

I got the code done in short time and enjoyed watching the patterns being created by the code I wrote.

import pygame
from pygame.constants import QUIT

#         If the ant is on a white cell:
#             Turn 90 degrees to the right (clockwise).
#             Flip the color of the cell to black.
#             Move forward one cell.
#         If the ant is on a black cell:
#             Turn 90 degrees to the left (counterclockwise).
#             Flip the color of the cell to white.
#             Move forward one cell.

class Ant:
    def __init__(self, x, y, upper_bound, cell_size, direction=0) -> None:
        self.x = x
        self.y = y
        self.upper_bound = upper_bound
        self.cell_size = cell_size
        self.direction = direction
        self.directions = ["up", "right", "down", "left"]

    def move_forward(self):
        if self.direction == 0:
            self.move_up()
        elif self.direction == 1:
            self.move_right()
        elif self.direction == 2:
            self.move_down()
        elif self.direction == 3:
            self.move_left()

    def turn_right(self):
        self.direction = (self.direction + 1) % len(self.directions)

    def turn_left(self):
        self.direction = (self.direction - 1) % len(self.directions)

    def move_up(self):
        if self.y == 0:
            self.y = self.upper_bound
        else:
            self.y = self.y - self.cell_size

    def move_down(self):
        if self.y == self.upper_bound:
            self.y = 0
        else:
            self.y = self.y + self.cell_size

    def move_left(self):
        if self.x == 0:
            self.x = self.upper_bound
        else:
            self.x = self.x - self.cell_size

    def move_right(self):
        if self.x == self.upper_bound:
            self.x = 0
        else:
            self.x = self.x + self.cell_size


pygame.init()

def main():
    WHITE = "white"
    BLACK = "black"
    WIDTH = 1200
    HEIGHT = 1200
    CELL_SIZE = 5
    SCREEN = pygame.display.set_mode((WIDTH, HEIGHT))
    CLOCK = pygame.time.Clock()
    running = True

    SCREEN.fill("black")

    GRID = {}
    grid_list = []
    for x in range(0, WIDTH, CELL_SIZE):
        for y in range(0, HEIGHT, CELL_SIZE):
            grid_list.append((x, y))

    for item in grid_list:
        GRID[item] = WHITE

    # print(GRID)

    middle_x = (WIDTH // CELL_SIZE) // 2 * CELL_SIZE
    middle_y = (HEIGHT // CELL_SIZE) // 2 * CELL_SIZE

    ant = Ant(middle_x, middle_y, WIDTH - CELL_SIZE, CELL_SIZE)

    def move_ant():
        is_white = GRID[(ant.x, ant.y)] == WHITE
        # ant.move_right()
        if is_white:
            GRID[(ant.x, ant.y)] = BLACK
            ant.turn_right()
        else:
            GRID[(ant.x, ant.y)] = WHITE
            ant.turn_left()

        ant.move_forward()

    def draw_grid():
        for cell in GRID:
            rect = pygame.Rect(cell[0], cell[1], CELL_SIZE - 2, CELL_SIZE - 2)
            pygame.draw.rect(SCREEN, GRID[(cell[0], cell[1])], rect)

    while running:
        draw_grid()
        move_ant()
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False

        pygame.display.update()

        CLOCK.tick(60)

    pygame.quit()


if __name__ == "__main__":
    main()

Maybe some day I will come back to this code and make it more elegant. For now, I'll just enjoy watching the patterns being created on my screen.

Desk Cleanup 2024

2024-10-02T00:00:00Z

Desk Cleanup

Few days ago I bought a monitor stand which came in today. It is a Meatanty Dual Monitor Stand Riser with 2 Drawers, 4 Usb Ports and Charging Pad. Recently I made some ergonomic changes to my working environment like changing to a vertical mouse. Although I do not have RSI yet, but sometimes I feel a little bit of pain in my wrist. Before it gets any worse, I have started making some changes to my environment.

Getting a monitor stand is part of these ergonomic changes. I noticed that I bend my neck slightly to look at the screen. This may not be the best in long term and with the stand, I see the monitor at my natural eye level.

As I was setting up the stand, I decided to embark on the quest of cleaning my desk which was slowly turning into a museum of all sorts of useless things. Nothing too revolutionary, just removing the clutter which unnecessarily occupied space and added zero value. At the end I'm proud of my achievement. Here is the obligatory photo of what it looks like as I'm writing this post.

Now let's get real. Soon I will have a bunch of other things (clutter) which will occupy most of the zen like space I have now. But, I will try to keep it like this or at least get into a routine of cleaning it up once a week. Until then, I'll enjoy the serenity in my room.

Write Your Own Memoize in JavaScript

2024-03-27T00:00:00Z

Write Your Own Memoize in JavaScript

We often default to using NPM modules for minor utility functions that could be straightforwardly implemented ourselves. While I have no issues with popular libraries like Lodash or Ramda, I believe they are often overutilized for tasks that can be accomplished with basic code.

I'll guide you through crafting your own memoize function. Memoization is an optimization technique that stores the results of expensive function calls and returns the cached result when the same inputs occur again. Here's how it works:

Execute your function with some or no arguments.
The function computes and returns a result.
On subsequent executions with the same arguments, the function retrieves and returns the result from the cache instead of recomputing it.

Below is the implementation for a basic memoize function:

function memoize(fn) {
  const cache = {};

  return function (...args) {
    const key = JSON.stringify(args);
    if (!(key in cache)) {
      const result = fn(...args);
      cache[key] = result;
    }
    return cache[key];
  };
}

Using the memoize function

First, define a function you wish to memoize. For instance:

function add(a, b) {
  console.log("Called add");
  return a + b;
}

Then, create a memoized version of this function:

const memoizedAdd = memoize(add);

Upon calling the memoizedAdd function with arguments, you'll observe the initial call logs "Called add" and returns the sum:

memoizedAdd(1, 2);
// called add
// 3

Repeating the call with the same arguments does not log "Called add" again but directly returns 3, demonstrating the memoization effect:

memoizedAdd(1, 2);
// 3

However, calling it with different arguments triggers the original add function:

memoizedAdd(2, 3);
// called add
// 5

Be cautious with attempting to simplify the memoize function excessively. Consider this terse version:

function memoize(fn) {
  const cache = {};

  return function (...args) {
    const key = JSON.stringify(args);
    cache[key] = cache[key] || fn(...args);
    return cache[key];
  };
}

This approach might seem elegant, but it fails for functions that do not return a value, demonstrating that simplicity and readability often outweigh cleverness:

function iReturnNothing() {
  console.log("iReturnNothing");
}

const memoizedIReturnNothing = memoize(iReturnNothing);

console.log(memoizedIReturnNothing()); // iReturnNothing
console.log(memoizedIReturnNothing()); // iReturnNothing

This issue reveals that the function was called twice, contrary to our expectations for memoization. Hence, it's preferable to embrace simplicity and clarity over brevity.

Clear setTimeout in JavaScript

2024-03-20T00:00:00Z

Clear setTimeout in JavaScript

One of the things I always have to look up is how to cancel a setTimeout in JavaScript.

This is a quick note for myself and anyone else who might need it.

Creating a timer

To create a timer in JavaScript, you can use the setTimeout function. This function takes two arguments: a function to execute and a time in milliseconds to wait before executing the function.

Here's an example:

const timer = setTimeout(() => {
	console.log("Hello, world!");
}, 1000);

In this code, the setTimeout function will execute the function after 1000 milliseconds (1 second).

If we console.log the timer variable, we will see that it is a number. This number is the ID of the timer.

Cancelling a timer

To cancel a timer, you can use the clearTimeout function. This function takes the ID of the timer as an argument.

Here's an example:

clearTimeout(timer);

In this code, the clearTimeout function will cancel the timer with the ID stored in the timer variable.

That's it! Now we know how to cancel a timeout in JavaScript.

From Quadratic to Linear

2024-02-28T00:00:00Z

From Quadratic to Linear

Lately, I've been immersing myself in basic coding exercises to refresh concepts that I learned years ago but haven't utilized much recently.

While going through my private repositories, I came across code from a tech test I completed for a job I applied for.

The task was a simple one. Given an array of numbers, find two elements whose sum equals a target value, then return the indices of these two elements.

Motivated by nostalgia, I decided to tackle this task again, this time using Python.

This is my data

nums = [
    50, -21, 32, -349, 701, 430, -313, 832, -947, 560,
    324, -456, 982, -123, 567, 234, -987, 654, 321, -432,
    543, 890, -101, -202, -303, 404, -505, 606, -707, 808,
    -909, 101, 212, -313, 414, -515, 616, -717, 818, -919,
    20, 31, -42, 53, -64, 75, -86, 97, -108, 119,
    130, -141, 152, -163, 174, -185, 196, -207, 218, -229,
    240, -251, 262, -273, 284, -295, 306, -317, 328, -339,
    350, -361, 372, -383, 394, -405, 416, -427, 438, -449,
    460, -471, 482, -493, 504, -515, 526, -537, 548, -559,
    570, -581, 592, -603, 614, -625, 636, -647, 658, -669,
    680, -691, 702, -713, 724, -735, 746, -757, 768, -779,
    790, -801, 812, -823, 834, -845, 856, -867, 878, -889,
    900, -911, 922, -933, 944, -955, 966, -977, 988, -999,
    111, 222, 333, 444, 555, 666, 777, 888, 999, -111,
    -222, -333, -444, -555, -666, -777, -888, -999, 0, 123
]
target = 222

With this data where I have a large array of numbers and with a target of 222, I expect my result to be [17, 19]

Value at nums[17] is 654 and the value at nums[19] is -432

So nums[17] + nums[19] = 222

Here's the initial Python code, which I converted from my original JavaScript:

def findIndexes(nums, target):
    for index_1, num_1 in enumerate(nums):
        for index_2, num_2 in enumerate(nums):
            if index_1 != index_2 and num_1 + num_2 == target:
                return [index_1, index_2]

This code works and produces the correct result.

I timed it using timeit and for 100,000 executions it takes approximately 8 seconds.

8 seconds is fast in human time but an eternity in computer time.

Is there a more efficient solution? Absolutely.

Can we do better?

Yes we can.

def findIndexes(num, target):
    indices = {}

    for i, num in enumerate(nums):
        difference = target - num

        if difference in indices:
            return [indices[difference], i]

        indices[num] = i

This revised method drastically reduces the execution time to 0.14 seconds for the same number of runs. It operates in linear time, making just one pass through the array, and utilizes a dictionary—a hash map, which is an extremely efficient data structure for lookup operations.

While the original method has a time complexity of O(n²), the optimized function operates at O(n), a significant improvement for large datasets.

Happy Coding!

How Working From Home Changed My Life

2024-02-16T00:00:00Z

How Working From Home Changed My Life

In the profession of software development, the transition to remote work has been a significant shift for many, including myself. My journey into the world of working from home began well before COVID-19.

It started as an experiment with flexibility, gradually transforming from a couple of days a week to a full-time remote work setup. This change of course was because of my managers who showed a level of trust in me.

Also, the change wasn't just a shift in where I worked but a profound change in how I lived and worked.

These are my reflections on this transformative experience, emphasizing the multitude of benefits it brought to my life and how it has also benefited my employer.

The Genesis of Remote Work

My professional career as a software developer kicked off in the late '90s. For nearly two decades, the office was my second home, a place where I spent the majority of my waking hours. The concept of working from anywhere but a corporate office was foreign, if not entirely unthinkable, at that time.

However, around 2018, a shift began. What initially started as a concession for more flexibility slowly morphed into a full-time remote work arrangement. This gradual transition allowed me to adapt my life around this newfound flexibility, venturing into a mode of work I had never thought possible.

Personal Benefits of Working from Home

One of the most significant changes I realized was that I had more time. Daily commute which took close to three hours both ways disappeared and I had these three hours available to me to pursue activities I could not.

Reading More

I noticed an increase in my reading. Without the need to commute, I found pockets of time that could be dedicated to reading. This not only expanded my knowledge but also became a source of relaxation and inspiration.

Quality Time with Family

Working from home allowed me to spend precious time with my family that would otherwise be lost in transit. This has strengthened my bond with my family. Spending more time with kids and spouse are priceless and it can do wonders for mental health. There is a spiritual dimension to this which can only be understood by experiencing it first-hand.

Enhanced Health and Exercise

The flexibility of working from home made it easier to incorporate exercise into my daily routine. I've been able to take better care of my health, both mentally and physically, which has had a profound impact on my overall well-being.

Appreciating Office Hangouts

On the rare occasions when I do visit the office or engage in work-related gatherings, I find myself enjoying these interactions more than ever. The change of scene and the physical presence of colleagues offer a refreshing break from the norm, making these moments more memorable and enjoyable.

Benefits for My Employer

The transition to remote work has not only been beneficial for me but also for my employer.

I've been able to deliver consistent, high-quality work without the distractions and interruptions common in an office environment. This has led to greater efficiency and innovation, benefiting my employer through improved project outcomes and a more engaged, motivated employee.

Conclusion

The journey to becoming a full-time remote worker has been a revelation. It has not only changed my approach to work but has also enriched my personal life in numerous ways. The benefits extend beyond the individual to the employer, challenging traditional notions of the workplace.

As we move forward, it's clear that remote work can offer a sustainable, productive, and fulfilling way of working for many, proving that with the right mindset and discipline, work is not a place you go, but something you do—regardless of location.

Get Indexes of Negative Numbers from a List in Python

2024-02-07T00:00:00Z

Get Indexes of Negative Numbers from a List in Python

Today I was working on some code in which I had to get indexes of items in a list based on a condition. I found it interesting and thought of writing a post about a similar problem.

Here it is.

Given a list containing both positive and negative numbers, the goal is to find indexes of all negative numbers.

numbers = [1, 5, -9, -3, 0, -3]

To get indexes of all negative numbers, I used the enumerate function with a condition in a list comprehension.

The enumerate function is a built-in function that returns an enumerable object. It contains pairs of indexes and values from a list.

By combining enumerate with list comprehension, I can effectively get the indexes of all negative numbers.

def find_negative_indexes(numbers):
    indexes = [index for index, val in enumerate(numbers) if val < 0]
    return indexes

Printing the output of find_negative_indexes method

print(find_negative_indexes(numbers))

produces this output, showing a list of indexes of all negative numbers in the list.

[2, 3, 5]

I also like writing tests for all my code, so here is the complete script

import unittest


def find_negative_indexes(numbers):
    indexes = [i for i, n in enumerate(numbers) if n < 0]
    return indexes


class TestFindNegativeIndexes(unittest.TestCase):
    def test_find_negative_indexes(self):
        self.assertEqual(find_negative_indexes([1, -2, 3, -4, 5]), [1, 3])
        self.assertEqual(find_negative_indexes([1, 2, 3, 4, 5]), [])
        self.assertEqual(find_negative_indexes([-1, -2, -3, -4, -5]), [0, 1, 2, 3, 4])
        self.assertEqual(find_negative_indexes([]), [])


if __name__ == "__main__":
    unittest.main()

Happy Coding!

7 Essentials for Learning TypeScript

2024-02-05T00:00:00Z

7 Essentials for Learning TypeScript

TypeScript is my preferred langauge for writing front-end code or anything node.js. I have been saved by the Type System numerous time. It has helped me track down potential errors which would have only surfaced during runtime. I think there is value in learning TypeScript and I strongly recommend to anyone who writes front-end code.

I was recently mentoring a junior programmer and I created a list of things I felt he should now. This is that list.

Embrace Type Annotations

TypeScript’s core feature is its ability to type-check your code, catching errors before they run. Use type annotations for variables, function parameters, and return types to take full advantage of this feature. This not only helps with catching errors early but also improves code documentation.

function add(a: number, b: number): number {
  return a + b;
}

Utilize Interfaces and Types for Complex Objects

When dealing with complex objects, leverage interfaces or type aliases to define their structure. This makes code more readable and ensures objects conform to a specific structure, reducing the likelihood of bugs.

interface User {
  name: string;
  age: number;
}

function greet(user: User) {
  console.log(`Hello, ${user.name}!`);
}

Master Advanced Types

TypeScript offers advanced types like unions, generics, and intersection types, allowing for more flexible and reusable code structures. Use these to write code that can work with multiple types or to enforce certain constraints on generics.

function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

const merged = merge({ name: "John" }, { age: 30 });

Leverage Utility Types

TypeScript’s utility types (like Partial, Readonly, and Record<K, T>) provide shortcuts for common type transformations. These can significantly reduce boilerplate code and increase flexibility.

function updateProfile(user: User, fieldsToUpdate: Partial<User>) {
  return { ...user, ...fieldsToUpdate };
}

Use Enums for Fixed Values

Enums are a great way to handle a set of fixed values in an application, like status codes or configuration options. They improve code readability and reduce errors related to using incorrect or misspelled string values.

enum Status {
  Active,
  Inactive,
  Suspended,
}

let userStatus: Status = Status.Active;

Implement Module Augmentation for Library Extensions

Sometimes, you might need to extend the types of an existing library without altering its source code. TypeScript’s module augmentation allows you to add new properties or methods to existing modules safely.

import "some-library";

declare module "some-library" {
  interface SomeLibraryType {
    newMethod(): void;
  }
}

Use Type Guards and Type Predicates

Type guards and predicates allow you to narrow down the type of an object within conditional blocks, making it easier to work with union types and ensuring type safety at runtime.

function isNumber(value: any): value is number {
  return typeof value === "number";
}

if (isNumber(someValue)) {
  console.log(someValue.toFixed(2)); // This is safe
}

These seven tips are a good head start to build TypeScript skills.

Soon you'll find yourself as an expert in TypeScript.

Wax on wax off.

Handling Single Record Queries in Rails with Grace

2024-02-05T00:00:00Z

Handling Single Record Queries in Rails with Grace

In Ruby on Rails, when dealing with database queries, there are instances where we anticipate a query to return a single record. This expectation arises in scenarios where the uniqueness of a record is integral to the application's logic. However, databases can sometimes contain duplicates or multiple records that meet the query criteria, leading to potential conflicts or unexpected behavior in our application. To ensure robust and error-free application behavior, it's essential to handle these cases effectively.

Consider a scenario where we query the Book model for all its records:

irb(main):018> Book.all
  Book Load (0.1ms)  SELECT "books".* FROM "books" /* loading for pp */ LIMIT ?  [["LIMIT", 11]]
=>
[#<Book:0x000000010e29cbd8
  id: 1,
  title: "Catcher in The Rye",
  price: 0.1599e2,
  created_at: Wed, 17 Jan 2024 09:55:46.668892000 UTC +00:00,
  updated_at: Wed, 17 Jan 2024 10:09:26.612252000 UTC +00:00,
  published_date: nil>,
 #<Book:0x000000010e29ca98
  id: 2,
  title: "Dracula",
  price: 0.2299e2,
  created_at: Wed, 17 Jan 2024 10:30:08.507102000 UTC +00:00,
  updated_at: Wed, 17 Jan 2024 10:30:08.507102000 UTC +00:00,
  published_date: nil>,
 #<Book:0x000000010e29c958
  id: 3,
  title: "Catcher in The Rye",
  price: 0.2299e2,
  created_at: Mon, 05 Feb 2024 07:27:12.511819000 UTC +00:00,
  updated_at: Mon, 05 Feb 2024 07:27:12.511819000 UTC +00:00,
  published_date: nil>]
irb(main):019>

In this example, we retrieve multiple Book records. While this direct fetch is straightforward for multiple records, complications arise when our logic expects only a single record in return.

The Challenge of Ensuring Uniqueness

Suppose we want to fetch a book by its title, expecting that title to be unique. However, if our database has multiple entries for the same title, this assumption breaks, and our application might behave unpredictably.

To tackle this, we could write a method like get_book:

def get_book(title)
    books = Book.where(title: title)
    raise ActiveRecord::RecordNotUnique if books.many?

    return books.first
end

This method fetches all books matching the given title and raises an exception if more than one record is found, effectively enforcing our uniqueness constraint. Here's how it behaves:

irb(main):040> get_book("Catcher in The Rye")
  Book Count (0.4ms)  SELECT COUNT(*) FROM (SELECT 1 AS one FROM "books" WHERE "books"."title" = ? LIMIT ?) subquery_for_count  [["title", "Catcher in The Rye"], ["LIMIT", 2]]
(irb):35:in `get_book': ActiveRecord::RecordNotUnique (ActiveRecord::RecordNotUnique)
irb(main):041>

A More Elegant Solution with .sole

While the above method works, Rails offers a cleaner, more idiomatic way to achieve the same result with the .sole method. This method is designed to return a single record and automatically raises an ActiveRecord::SoleRecordExceeded exception if more than one record matches the query, simplifying our approach:

The get_book method can be shortened to this

def get_book(title)
    Book.where(title: title).sole
end

irb(main):045> get_book("Catcher in The Rye")
  Book Load (0.4ms)  SELECT "books".* FROM "books" WHERE "books"."title" = ? ORDER BY "books"."id" ASC LIMIT ?  [["title", "Catcher in The Rye"], ["LIMIT", 2]]
/Users/deepak/.rbenv/versions/3.2.2/lib/ruby/gems/3.2.0/gems/activerecord-7.1.3/lib/active_record/relation/finder_methods.rb:141:in `sole': Wanted only one Book (ActiveRecord::SoleRecordExceeded)

This approach is not only cleaner but also more efficient, as it communicates our intent more clearly and leverages Rails' built-in mechanisms for enforcing record uniqueness.

Understanding Symbols in Ruby Programming Language

2024-01-23T00:00:00Z

Understanding Symbols in Ruby Programming Language

What is a Symbol in Ruby?

In Ruby, a symbol is a lightweight, immutable identifier. It is often used in situations where a string would traditionally be used, but it offers performance benefits. Symbols are denoted by a colon (:) followed by a name. For example, :user and :email are symbols.

Key Characteristics of Symbols

Immutability: Unlike strings, symbols are immutable. Once a symbol is created, it cannot be altered. This property makes them safe to use as identifiers or keys in hashes.
Uniqueness: Each symbol is unique throughout a Ruby program. No matter where in the program it's used, a symbol represents the same value or state.
Efficient: Symbols are more memory-efficient than strings. Since they are unique, Ruby internally stores each symbol only once, reducing memory usage and speeding up comparisons.

Common Uses of Symbols in Ruby

As Hash Keys

One of the most common uses of symbols is as keys in hashes. Since they are immutable and unique, they are perfect for identifying values within a hash. For example:

user = {:name => "Alice", :age => 30}

Method & Constant Names

In Ruby, method names and constant names are internally symbols. This is part of Ruby’s design, which treats everything as an object, including method names and constants.

Representing States or Options

Symbols are often used to represent states, options, or specific conditions within a program, largely because of their readability and symbolic nature.

Comparison with Strings

While symbols are similar to strings, they are not the same. The key difference lies in their identity and immutability. Two strings with the same content are considered different objects, while two symbols with the same name are exactly the same object.

For example:

"string" == "string" # true, but they are different objects
:symbol == :symbol # true, and they are the same object

When to Use Symbols

Use symbols when an identifier is needed. They are perfect for keys in hashes, representing method names, states, or labels that do not need the flexibility of a string.
Avoid using symbols when you need string-like behavior, such as concatenation, or when the text is user-generated and not a fixed identifier.

Conclusion

Symbols in Ruby offer a unique and efficient way to handle identifiers within your code. Their immutability, uniqueness, and memory efficiency make them a preferred choice for keys in hashes, representing method names, and more. Understanding when and how to use symbols can greatly enhance Ruby programming experience.