DEV Community: Soumendra Kumar Sahoo

Why should you use attrs more

Soumendra Kumar Sahoo — Tue, 20 Aug 2024 01:51:15 +0000

Introduction

Python's attrs library is a game-changer for developers looking to simplify class creation and reduce boilerplate code. This libray is even trusted by NASA.
Created by Hynek Schlawack in 2015, attrs has quickly become a favorite tool among Python developers for its ability to automatically generate special methods and provide a clean, declarative way to define classes.
dataclasses is a kind of subset of attrs.

Why attrs is useful:

Reduces boilerplate code
Improves code readability and maintainability
Provides powerful features for data validation and conversion
Enhances performance through optimized implementations

2. Getting Started with attrs

Installation:
To get started with attrs, you can install it using pip:

pip install attrs

Basic usage:
Here's a simple example of how to use attrs to define a class:

import attr

@attr.s
class Person:
    name = attr.ib()
    age = attr.ib()

# Creating an instance
person = Person("Alice", 30)
print(person)  # Person(name='Alice', age=30)

3. Core Features of attrs

a. Automatic method generation:

attrs automatically generates init, repr, and eq methods for your classes:

@attr.s
class Book:
    title = attr.ib()
    author = attr.ib()
    year = attr.ib()

book1 = Book("1984", "George Orwell", 1949)
book2 = Book("1984", "George Orwell", 1949)

print(book1)  # Book(title='1984', author='George Orwell', year=1949)
print(book1 == book2)  # True

b. Attribute definition with types and default values:

import attr
from typing import List

@attr.s
class Library:
    name = attr.ib(type=str)
    books = attr.ib(type=List[str], default=attr.Factory(list))
    capacity = attr.ib(type=int, default=1000)

library = Library("City Library")
print(library)  # Library(name='City Library', books=[], capacity=1000)

c. Validators and converters:

import attr

def must_be_positive(instance, attribute, value):
    if value <= 0:
        raise ValueError("Value must be positive")

@attr.s
class Product:
    name = attr.ib()
    price = attr.ib(converter=float, validator=[attr.validators.instance_of(float), must_be_positive])

product = Product("Book", "29.99")
print(product)  # Product(name='Book', price=29.99)

try:
    Product("Invalid", -10)
except ValueError as e:
    print(e)  # Value must be positive

4. Advanced Usage

a. Customizing attribute behavior:

import attr

@attr.s
class User:
    username = attr.ib()
    _password = attr.ib(repr=False)  # Exclude from repr

    @property
    def password(self):
        return self._password

    @password.setter
    def password(self, value):
        self._password = hash(value)  # Simple hashing for demonstration

user = User("alice", "secret123")
print(user)  # User(username='alice')

b. Frozen instances and slots:

@attr.s(frozen=True) # slots=True is the default
class Point:
    x = attr.ib()
    y = attr.ib()

point = Point(1, 2)
try:
    point.x = 3  # This will raise an AttributeError
except AttributeError as e:
    print(e)  # can't set attribute

c. Factory functions and post-init processing:

import attr
import uuid

@attr.s
class Order:
    id = attr.ib(factory=uuid.uuid4)
    items = attr.ib(factory=list)
    total = attr.ib(init=False)

    def __attrs_post_init__(self):
        self.total = sum(item.price for item in self.items)

@attr.s
class Item:
    name = attr.ib()
    price = attr.ib(type=float)

order = Order(items=[Item("Book", 10.99), Item("Pen", 1.99)])
print(order)  # Order(id=UUID('...'), items=[Item(name='Book', price=10.99), Item(name='Pen', price=1.99)], total=12.98)

5. Best Practices and Common Pitfalls

Best Practices:

Use type annotations for better code readability and IDE support
Leverage validators for data integrity
Use frozen classes for immutable objects
Take advantage of automatic method generation to reduce code duplication

Common Pitfalls:

Forgetting to use @attr.s decorator on the class
Overusing complex validators that could be separate methods
Not considering the performance impact of extensive use of factory functions

6. attrs vs Other Libraries

Library	Features	Performance	Community
attrs	Automatic method generation, attribute definition with types and default values, validators and converters	Better performance than manual code	Active community
pydantic	Data validation and settings management, automatic method generation, attribute definition with types and default values, validators and converters	Good performance	Active community
dataclasses	Built into Python 3.7+, making them more accessible	Tied to the Python version	Built-in Python library

attrs and dataclasses are faster than pydantic¹.

Comparison with dataclasses:

attrs is more feature-rich and flexible
dataclasses are built into Python 3.7+, making them more accessible
attrs has better performance in most cases
dataclasses are tied to the Python version, while attrs as an external library can be used with any Python version.

Comparison with pydantic:

pydantic is focused on data validation and settings management
attrs is more general-purpose and integrates better with existing codebases
pydantic has built-in JSON serialization, while attrs requires additional libraries

When to choose attrs:

For complex class hierarchies with custom behaviors
When you need fine-grained control over attribute definitions
For projects that require Python 2 compatibility (though less relevant now)

7. Performance and Real-world Applications

Performance:
attrs generally offers better performance than manually written classes or other libraries due to its optimized implementations.

Real-world example:

from attr import define, Factory
from typing import List, Optional

@define
class Customer:
    id: int
    name: str
    email: str
    orders: List['Order'] = Factory(list)

@define
class Order:
    id: int
    customer_id: int
    total: float
    items: List['OrderItem'] = Factory(list)

@define
class OrderItem:
    id: int
    order_id: int
    product_id: int
    quantity: int
    price: float

@define
class Product:
    id: int
    name: str
    price: float
    description: Optional[str] = None

# Usage
customer = Customer(1, "Alice", "alice@example.com")
product = Product(1, "Book", 29.99, "A great book")
order_item = OrderItem(1, 1, 1, 2, product.price)
order = Order(1, customer.id, 59.98, [order_item])
customer.orders.append(order)

print(customer)

8. Conclusion and Call to Action

attrs is a powerful library that simplifies Python class definitions while providing robust features for data validation and manipulation. Its ability to reduce boilerplate code, improve readability, and enhance performance makes it an invaluable tool for Python developers.

Community resources:

GitHub repository: https://github.com/python-attrs/attrs
Documentation: https://www.attrs.org/
PyPI page: https://pypi.org/project/attrs/

Try attrs in your next project and experience its benefits firsthand. Share your experiences with the community and contribute to its ongoing development. Happy coding!

https://stefan.sofa-rockers.org/2020/05/29/attrs-dataclasses-pydantic/ ↩

Production Readiness Checklist

Soumendra Kumar Sahoo — Sun, 04 Aug 2024 09:13:58 +0000

I have been working on multiple pojects where I have moved applications from PoC to Production.
These are the checklists I have prepared for myself and my team to ensure we are ready for production.
Here the checklists are in focus as the application is in Python programming language and deployed to AWS via Kubernetes.
Not all of these are mandatory, but they are the ones I have found most useful.

1. Alerts & Metrics

[ ] Are there alerts set up for infrastructure issues (e.g., memory or CPU usage increase, service unavailability)?
[ ] Are there alerts set up for critical application-specific logic failures?
[ ] Can we view historical data (past few hours/days) of infrastructure and resource usage?
[ ] Is there a real-time monitoring dashboard in place?

2. Dashboard and SOP

[ ] Is there an SOP document for handling alerts and known issues?
[ ] Are there runbooks available for common scenarios?
[ ] Is there an incident response plan in place?

3. On-call mapping and cadence

[ ] Is there an on-call person mapping for application-level issues?
[ ] Is there an on-call person mapping for infrastructure-related issues?
[ ] Is there a defined rotation schedule and escalation policy?

4. Deployment

[ ] Has the appropriate instance type (GPU or CPU) been determined?
[ ] Has the required server type been specified?
[ ] Is there multi-availability zone support for failover?
[ ] Is there support for multiple regions?
[ ] Is auto-scaling set up (e.g., HPA, Keda) for traffic spikes?
[ ] Are health checks configured for the server?
[ ] Have resource limits been defined and documented?
[ ] Is there a blue-green or canary deployment strategy in place?
[ ] Is there a defined rollback plan and procedure?

5. Observability and tracing

[ ] Is there a dashboard showing relevant metrics (e.g., request count, HTTP status codes, usage)?
[ ] Can we trace a single request end-to-end for debugging purposes?
[ ] Is there a log aggregation and analysis system in place?
[ ] Is distributed tracing implemented?

6. Load tests

[ ] Has capacity planning been performed to determine the server's load handling capabilities?
[ ] Are there defined performance benchmarks?
[ ] Has stress testing been conducted?

7. Quality

[ ] Are there automated unit tests?
[ ] Are there automated integration tests?
[ ] Is static code analysis (e.g., complexity checks) performed?
[ ] Is code coverage measured and at an acceptable level?
[ ] Are there production sanity test cases?
[ ] Is there a CI/CD pipeline in place?
[ ] Are security scans and vulnerability assessments performed regularly?

8. Release

[ ] Is Swagger/OpenAPI documentation available and up-to-date?
[ ] Is there a versioning system for APIs and releases?
[ ] Is there an established communication channel for scheduled maintenance?
[ ] Is there a change management process?
[ ] Are feature flags used for gradual rollout of new features?

9. Disaster Recovery and Business Continuity

[ ] Are backup and restore procedures in place and tested?
[ ] Is there a data replication strategy?
[ ] Have Recovery Time Objective (RTO) and Recovery Point Objective (RPO) been defined?
[ ] Are regular disaster recovery drills conducted?

10. Compliance and Security

[ ] Is data encrypted at rest and in transit?
[ ] Are access control and authentication mechanisms in place?
[ ] Are regular security audits conducted?
[ ] Does the application comply with relevant industry standards (e.g., GDPR, HIPAA)?

11. Documentation

[ ] Is system architecture documentation available and up-to-date?
[ ] Is API documentation complete and current?
[ ] Are operational procedures documented?
[ ] Is there a comprehensive troubleshooting guide?

@property in Python

Soumendra Kumar Sahoo — Fri, 24 Mar 2023 09:25:11 +0000

Introduction

Sure! Here's an introduction to Python's @property decorator with code snippets:

In Python, a decorator is a special function that can modify other functions' behavior. You can think of decorators as a way to "wrap" one function with another. This can be useful for adding functionality to functions without changing their code.

One built-in decorator in Python is @property, which is used with the property() function. Here's an example that shows how you can use @property to define a read-only property for a class:
```
class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

c = Circle(5)
print(c.radius) # 5
c.radius = 10 # AttributeError: can't set attribute
```
In this example, we define a class Circle with a private attribute _radius. We then use the @property decorator to define a method radius() that returns the value of _radius. When we create an instance of Circle, we can access the value of _radius using the .radius property. However, since we haven't defined a setter method for .radius, trying to set its value will result in an error.
Use Cases

Here's an explanation of why you should use @property with example usages:

Using the @property decorator can be helpful in several ways when defining properties in a class. Here are some examples:
1. Encapsulation: By using @property, you can control access to an attribute by defining getter, setter, and deleter methods. This allows you to hide the implementation details of an attribute and only expose a public interface for accessing it.
```
class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

c = Circle(5)
print(c.radius) # 5
```
In this example, we define a class Circle with a private attribute _radius. We then use the @property decorator to define a method radius() that returns the value of _radius. When we create an instance of Circle, we can access the value of _radius using the .radius property.
1. Validation: You can use the setter method to validate the value being assigned to an attribute. For example, you can check if the value is within a specific range or meets certain conditions before assigning it.
```
class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("Radius cannot be negative")
        self._radius = value

c = Circle(5)
print(c.radius) # 5
c.radius = -1 # ValueError: Radius cannot be negative
```
In this example, we define a class Circle with a private attribute _radius. We then use the @property decorator to define a method radius() that returns the value of _radius, and the .setter decorator to define a method radius() that sets the value of _radius .
1. Ease of use: Using @property makes it easy to define properties without manually calling the property() function. This can make your code more readable and easier to understand.
```
class Circle:
    def __init__(self, radius):
        self._radius = radius

    def get_radius(self):
        return self._radius

    def set_radius(self, value):
        if value < 0:
            raise ValueError("Radius cannot be negative")
        self._radius = value

    radius = property(get_radius, set_radius)

c = Circle(5)
print(c.radius) # 5
c.radius = -1 # ValueError: Radius cannot be negative
```
In this example, we define a class Circle with a private attribute _radius. We then define methods get_radius() and set_radius() for getting and setting the value of _radius. We use the property() function to create a property .radius that uses these methods.

This code achieves the same result as the previous example but is less readable and harder to understand. Using @property makes it easier to define properties more intuitively.

Overall, using @property can help you write cleaner and more maintainable code when defining properties in a class.
Syntax and Examples

This example shows how you can use @property, along with the .setter and .deleter decorators to define a property with getter, setter, and deleter methods:
```
class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("Radius cannot be negative")
        self._radius = value

    @radius.deleter
    def radius(self):
        del self._radius

c = Circle(5)
print(c.radius) # 5
c.radius = 10
print(c.radius) # 10
del c.radius
```
In this example, we define a class Circle with a private attribute _radius. We then use the @property decorator to define a method radius() that returns the value of _radius. We also use the .setter decorator to define a method radius() that sets the value of _radius, and the .deleter decorator to define a method radius() that deletes _radius.

When we create an instance of Circle, we can access and modify the value of _radius using the .radius property. We can also delete _radius using the del statement.
Conclusion

Key points and benefits of using @property:

* `@property` is a decorator that can be used to define properties in a class.
* It allows you to control access to an attribute by defining getter, setter, and deleter methods.
* Using `@property` can help you achieve encapsulation by hiding the implementation details of an attribute and only exposing a public interface for accessing it.
* You can use the setter method to validate the value being assigned to an attribute before assigning it.
* Using `@property` makes it easy to define properties without manually calling the `property()` function. This can make your code more readable and easier to understand.

Overall, using `@property` can help you write cleaner and more maintainable code when defining properties in a class.

First published on my primary blog.

Usage of backward slash (\) in Python

Soumendra Kumar Sahoo — Sat, 10 Dec 2022 05:55:53 +0000

In Python, the backslash (\) character is used for several purposes, such as:

To specify escape sequences, like \n for a newline, \t for a tab, etc.
To escape special characters - the backward slash is used to escape special characters such as quotation marks and newline characters in strings. For example:

# escaping special characters in a string

my_string = "This is a string with a \"quotation mark\" and a newline character \n in it"
print(my_string)

To split a string into multiple lines by using the \ character at the end of each line. For example, the following code will print hello world on two lines:

# continuing a line of code

print("This is a very long line of code that cannot fit on one line" \
      "so we are using the backward slash to continue it on the next line")

It's important to note that in Python, the backslash character is used for escaping characters, and it is not the same as the forward slash (/) character, which is used for division. For example, the following code will print 5.0:

print(10 / 2)

You may further be interested in:

Usage of forward slash (/) in Python

Soumendra Kumar Sahoo — Tue, 06 Dec 2022 04:48:12 +0000

In Python, the forward-slash (/) has several different uses depending on the context in which it appears. Some of the main uses of the forward slash in Python include:

Division

When used between two numeric values, the forward slash performs division.
For example, 10 / 3 evaluates to 3.3333333333333335.

>>> 10/3
3.3333333333333335

Floor division

When used between two numeric values, the forward slash followed by another forward slash (//) performs floor division, which rounds the result down to the nearest integer.
For example, 10 / 3 evaluates to 3, and 10 // 3 evaluates to 3.

>>> 10//3
3

Paths

In strings, the forward slash is often used as a separator in file paths or URLs.
For example:

path = "C:/Users/john/Documents/file.txt"
url = "https://www.example.com/path/to/resource"

Regular expressions

In regular expressions, the forward slash is often used to escape special characters. For example:

import re

pattern = r"\d+/\d+/\d+"
text = "The date is 01/01/2021"
match = re.search(pattern, text)

Thanks for reading, you can further check:

This article was first published here.

Factory Design Pattern

Soumendra Kumar Sahoo — Thu, 01 Dec 2022 12:51:33 +0000

There are several design patterns that are commonly used in Python programming. Some of the most common design patterns include:

Singleton: This design pattern ensures that a class has only one instance, and provides a global point of access to it.
Factory: This design pattern provides a way to create objects without specifying the exact class of object that will be created.
Adapter: This design pattern allows classes with incompatible interfaces to work together by wrapping the original class and providing a new interface.
Decorator: This design pattern allows new functionality to be added to an existing object without modifying its structure.
Observer: This design pattern allows objects to observe and react to changes in other objects.
Strategy: This design pattern allows the behavior of an algorithm to be changed at runtime.
Template: This design pattern defines the skeleton of an algorithm, allowing subclasses to provide specific implementation details.
Command: This design pattern allows you to encapsulate a request as an object, separating the request from the object that executes it.

These are just a few examples of the many design patterns that are available in Python. There are many more design patterns that can be used to solve common programming problems in Python, and choosing the right design pattern for a given situation can help to make your code more maintainable and scalable.

The factory design pattern is a popular object-oriented programming technique in Python. It is used to create new objects, hiding the complexity of object creation from the user. This allows for a more flexible and modular approach to object creation, as well as promoting code reuse.

The factory design pattern works by defining a factory class that is responsible for creating objects. The factory class has a method, typically called create(), that takes in the necessary parameters for creating an object and returns the newly created object. The user of the factory class does not need to know the details of how the object is created, they just call the create() method and get back the new object.

One of the key benefits of using the factory design pattern is that it allows for the creation of objects without specifying their exact class. This means that the factory can be used to create different types of objects, depending on the input provided to the create() method. This is useful when working with systems that may have different implementations of the same concept, such as different types of vehicles in a transportation application.

Another benefit of the factory design pattern is that it promotes code reuse. Since the factory class abstracts away the details of object creation, it can be used to create objects of different types without duplicating code. This means that the code for creating objects can be centralized in the factory class, making it easier to maintain and update.

To illustrate how the factory design pattern works in Python, let's consider a simple example. Suppose we have a Vehicle class that represents different types of vehicles, such as cars and trucks. We can use the factory design pattern to create instances of the Vehicle class by defining a VehicleFactory class.

class Vehicle:
    def __init__(self, type, model, year):
        self.type = type
        self.model = model
        self.year = year

class VehicleFactory:
    @staticmethod
    def create(type, model, year):
        if type == 'car':
            return Car(model, year)
        elif type == 'truck':
            return Truck(model, year)

class Car(Vehicle):
    def __init__(self, model, year):
        super().__init__('car', model, year)

class Truck(Vehicle):
    def __init__(self, model, year):
        super().__init__('truck', model, year)

# create a car using the factory
car = VehicleFactory.create('car', 'Honda Civic', 2021)

# create a truck using the factory
truck = VehicleFactory.create('truck', 'Ford F-150', 2020)

In this example, the VehicleFactory class has a create() method that takes in the type, model, and year of the vehicle to be created. Depending on the type provided, the create() method creates and returns an instance of either the Car or Truck class, which inherit from the Vehicle class. This allows us to create different types of vehicles without specifying their exact class, and without duplicating code for creating objects.

In conclusion, the factory design pattern is a useful technique in Python programming for creating objects in a flexible and modular way. It can help you to create a more scalable and maintainable codebase by abstracting away the details of object creation and allowing for a more flexible approach to object creation.

Disclaimer: The above text is generated by the chat GPT

Follow me on Twitter soumendrak for more such posts.

This post was first published on: https://blog.soumendrak.com/factory-design-pattern

Learn Python Programming

Soumendra Kumar Sahoo — Tue, 08 Nov 2022 09:46:10 +0000

Python has been around since the 90s and an enormous amount of content is there to learn Python. While this is good for any language this creates information overload and decision paralysis in learning in a structured manner.
Note: There is no official certification for Python programming

Here is a list of materials to help beginners in Python programming:

Interactive way

Here you can try on coding on the browser itself without installing anything.

Books

A more extensive list of books can be found at awesome python books

Courses

Programming for Everybody

Videos

Programming with Mosh : 6hr long Python course
Corey Schafer : Python short tutorials
Intellipaat: Python long tutorials in Hindi and all
freeCodeCamp: 12 beginner Python projects
NeuralNine: Python beginner, intermediate and advanced playlists
RealPython: Python tips and tricks
sentdex: Python beginner to advanced tutorials.
clearCode: Learn Python by making games

For more search awesome Youtube visit awesome-youtubers

Tutorials

Project-based learning
Much more can be found at Ultimate Python

Newsletters

Newsletters usually published weekly keep you up to date on the latest developments in the Python world.

Podcasts

If you are a podcast person, here is a list of podcasts related to Python.

This list will be updated from time to time whenever required.
Follow soumendrak_ for more such contents.

Aggregate Code timing in Python

Soumendra Kumar Sahoo — Wed, 20 Jul 2022 03:53:17 +0000

There are many ways to get how much time a function takes in Python. Here is an easy decorator implementation to check how much time a function takes.

from functools import wraps
import time


def timeit(func):
    @wraps(func)
    def timeit_wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        result = func(*args, **kwargs)
        end_time = time.perf_counter()
        total_time = end_time - start_time
        print(f'Function {func.__name__}{args} {kwargs} took {total_time:.4f} seconds')
        return result
    return timeit_wrapper

@timeit
def my_func():
    # do stuff

This decorator can be used by decorating a function to get the time spent.
What if you want to aggregate this timing data in a timeframe, like how many times this function has been called, and what the maximum time is taken, for that, we need to use a library called codetiming.
Here is a sample use case:

# pip install codetiming
# pip install humanfriendly
from codetiming import Timer
from humanfriendly import format_timespan
from loguru import logger


@Timer(name="my_func", text=lambda secs: f"my_func elapsed time: {format_timespan(secs)}")
def my_func():
    ...

def get_aggregated_timings(cls):
    timed_function = "my_func"
    logger.info(
        f"\n{timed_function} count: {Timer.timers.count(timed_function)}\n"
        f"total: {Timer.timers.total(timed_function)}\n"
        f"max: {Timer.timers.max(timed_function)}\n"
        f"min: {Timer.timers.min(timed_function)}\n"
        f"mean: {Timer.timers.mean(timed_function)}\n"
        f"standard deviation: {Timer.timers.stdev(timed_function)}\n"
        f"median: {Timer.timers.median(timed_function)}\n"
    )
    Timer.timers.clear()  # clears all the timer data

This will find the aggregated time spent by my_func. Let's go through what each one of them will log:

count: Number of times the function has been called.
total: Sum of all the seconds elapsed in the function
max: Maximum time spent on a single flow
min: Minimum time spent on a single flow
mean: The average of all the time spent on that function
median: The median of all elapsed time
stdev: The standard deviation of all elapsed time

At the end Timer.timers.clear() clears the data stored In memory and starts from fresh for the next iteration.

Do you want to use an in-memory LRU cache with a timeout, you may check out this article:

Cache functions with timeout

I post on Python programming on my Twitter handle, you can follow me @soumendrak_

Originally posted at: my blog

Top Software Engineering Blogs

Soumendra Kumar Sahoo — Sun, 17 Jul 2022 05:58:00 +0000

This is a growing collection of blogs by software companies that you can read to get Engineering practices and Software Architecture ideas.

You can download this Bookmarks file and import it into your browser.

Python vs Golang vs Rust

Soumendra Kumar Sahoo — Tue, 17 May 2022 07:23:42 +0000

Test scenario

I have taken the Two sum problem from Leetcode.

The problem statement:

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Example 1:

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].

Example 2:

Input: nums = [3,2,4], target = 6
Output: [1,2]

Example 3:

Input: nums = [3,3], target = 6
Output: [0,1]

Constraints:
2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
Only one valid answer exists.

Implementation

I have used a hash map to solve this problem across all three languages.

Python

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hash_table = {}
        for i, num in enumerate(nums):
            target_num = target - num
            if num in hash_table:
                return i, hash_table[num]
            else:
                hash_table[target_num] = i
        return None

Python stats

Run time: 40ms
Memory usage: 14.5 MB

Golang

func twoSum(nums []int, target int) []int {
    hashMap := make(map[int] int)
    for i := 0; i < len(nums); i++{
        if _, found := hashMap[nums[i]]; found {
            ans := []int{i, hashMap[nums[i]]}
            return ans
        } else {
            hashMap[target- nums[i]]= i
        }
    }
    return nil
}

Golang stats

Run time: 4ms
Memory usage: 4.3 MB

Rust

use std::collections::HashMap;
impl Solution {
    pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
        let mut hash_table: HashMap<i32, i32> = HashMap::new();
    for i in 0..nums.len() {
        // println!("Processing number: {}", nums[i]);
        match hash_table.get(&nums[i]){
            Some(&x) => return vec![x, i as i32],
            None => hash_table.insert(target - nums[i], i as i32),
        };
    };
    return vec![-1, -1]
    }
}

Rust stats

Run time: 2ms
Memory usage: 2.2 MB

Conclusion

As per the results, Rust took the least memory and was the fastest of all three.

For more such insights follow me on Twitter.
Original post: Hashnode

When to stop code refactoring

Soumendra Kumar Sahoo — Sun, 17 Jan 2021 13:32:56 +0000

Taking too much time to refactor, which is blocking other dependent applications and priority tasks.
For developers CR is like a drug, a developer can refactor can keep on refactoring a complex codebase for ages. If CR is limited to no ROI (Return On Investment) the activity needs to be stopped.
Refactoring is not same as redesigning the code. It is easier to start the coding from scratch than to refactor your somebody else's or your own code. This needs to be learned before CR starts.