Forem: Elchonon Klafter

Using a Directed Acyclic Graph algorithm to predict productivity

Elchonon Klafter — Mon, 10 Feb 2025 01:00:12 +0000

The world is empowered by productivity. Society, financial markets and economics are driven by the measure of it's productive output. Therefore, methods and frameworks designed to maximize output and efficiency by optimizing time management, task prioritization, and workflow are essential for both individuals and organizations striving for success.

In an era where automation and AI-driven tools are reshaping industries, the application of value-adding algorithms and processes are an important part the future of software.
In the following article I will demonstrate how using a Directed Acyclic Graph (DAG) can accurately predict task completion and project timelines.

A Directed Acyclic Graph (DAG) represents a structured workflow where tasks (nodes) are connected by dependencies (edges) in a clear, one-way sequence, ensuring no circular dependencies or infinite loops. This structure is crucial in project planning where certain tasks must be completed before others can begin. For example, in software development, "Design UI" must precede "Implement UI," which then must precede "Testing." Since DAGs maintain a topological order, they enable efficient scheduling, parallel execution of independent tasks, and prevention of deadlocks, ensuring smooth and optimized project execution.

Using the following example dataset:

tasks = [
    { 
        "id": 1, 
        "name": "Design UI", 
        "days_length": 3, 
        "dependencies": [] 
    },
    { 
        "id": 2, 
        "name": "Implement UI", 
        "days_length": 7, 
        "dependencies": [1] 
    },
    { 
        "id": 3, 
        "name": "Testing", 
        "days_length": 2, 
        "dependencies": [2] 
    },
    { 
        "id": 4, 
        "name": "Project Documentation", 
        "days_length": 4, 
        "dependencies": [] 
    }
]

To determine the correct order of tasks, we need to perform a topological sort of the tasks which will ensure that dependent tasks are performed before their edges. The first step of the process is to build an adjacency list containing each task and their in-degrees (tasks dependent on it). Once we have this we can begin ordering the schedule of tasks by adding in all tasks without any incoming edges. Using our sample data, this will be Project Documentation and Design UI. Once we have added these to our list, we can iterate over each of those tasks and then add each of their dependencies to our schedule.

from collections import defaultdict, deque
from datetime import datetime, timedelta, time

def topological_sort(self, tasks):
    # Step 1: Calculate in-degrees and construct the adjacency list
    in_degree = defaultdict(int)
    adjacency_list = defaultdict(list) 
    for task in tasks.values():
        # Initialize in-degree for the current task
        in_degree[task.id] = in_degree.get(task.id, 0)
        for dependency in task.dependencies:
            adjacency_list[dependency.id].append(task)
            in_degree[task.id] += 1

    # Step 2: Collect all tasks with in-degree 0 (tasks with no dependencies) for initial adding
    zero_in_degree = deque([task for task in tasks.values() if in_degree[task.id] == 0])

    # Step 3: Process tasks with in-degree 0
    top_order = []
    while zero_in_degree:
        # 3.1: add tasks that have no dependencies
        current_task = zero_in_degree.popleft()
        top_order.append(current_task)

        # Reduce the in-degree of dependent tasks
        # 3.2: process dependent tasks 
        # get list of tasks that point to this task
        for dependent_task in adjacency_list[current_task.id]:
            # subtract -1 to account for the parent task that points to this
            in_degree[dependent_task.id] -= 1  # Step 1: Reduce the in-degree of each dependent task

            # this dependent task has no other dependencies
            if in_degree[dependent_task.id] == 0: # Step 2: Check if this dependent task now has no incoming edges (all depedendencies are resolved)
                zero_in_degree.append(tasks[dependent_task.id]) # Step 3: Add it to the processing queue (tasks with no incoming edges)

    return top_order

While the code example above will order all tasks in their required order, by adding logic to determine start and end dates for each tasks based on anticipated task length, we can extrapolate the anticipate completion date of each task and accurately predict project timeframe and completion.

Hashing, Salting, Cryptography. Help!

Elchonon Klafter — Thu, 16 Jan 2025 23:57:36 +0000

Writing secure software is essential in today’s cyber landscape, where threats evolve every day. Security considerations must be integrated from the very beginning of the development lifecycle. While larger teams may have dedicated roles like Security Analysts, Engineers, or Penetration Testers, smaller teams without these specializations must still adopt basic measures to safeguard their systems.
In the article below, I will discuss some of the most basic security considerations and concepts that every developer should be familiar with.

Identity and Access Management (IAM)

Proper authentication of a user and implementing correct authorization is key to securing a system and to ensure that data is not accessed by unauthorized actors.

Authorization Patterns

Role-Based Access Control (RBAC)
Attribute-Based Access Control (ABAC)
Policy-Based Access Control (PBAC)

The best approach often depends on the system requirement and may involve combining multiple patterns for optimal security.

Authentication Methods

While proper Access Control ensures that the resources accessed aligns with policy, authentication is key to ensure that the actor is valid.
Common authentication procedures include:

Password authentication
Single Sign-On (SSO)
Biometric identifiers such a fingerprint, voice or retina pattern
Two-Factor Authentication (2FA)
Hardware or Token-Based authentication

By combining robust authentication with effective access control, a developer can significantly reduce the risk of unauthorized access and maintain system security.

Web Application Security Vulnerabilities

Web applications are powerful tools, but without proper security measures, they can be exploited to compromise user data or perform unauthorized actions. These common vulnerabilities potentially can have a serious impact on your system.

CORS (Cross-Origin Resource Sharing)

When improperly configured, this can be exploited to allow unauthorized users to access resources and sensitive data.

XSS (Cross-Site Scripting)

By injecting malicious JavaScript code onto an infected website, which is executed in the user's browser, this can potentially steal user's information or perform unauthorized actions on their behalf.

CSRF (Cross-Site Request Forgery)

This attack tricks the user into unknowingly running malicious actions on an authenticated website, the attack exploits cookies and session data to perform unauthorized actions on the users behalf.

These sort of attacks can be easily mitigated by implementing input validation, basic protections and secure coding practices.

Data Security

When authentication fails or systems are exploited, safeguards must be in place to preserve the integrity and security of the data.
These can include:

encryption
timeout and session management
rate limiting
audit logs
Intrusion Detection and Prevention Systems (IDPS)

To summarize, security is a complex multi-faceted responsibilty that must be implemented at every stage. There are many resources and tools that a developer may utilize to keep their systems safe and secure.

Decorators & Class Property in Python

Elchonon Klafter — Tue, 17 Dec 2024 16:57:12 +0000

In this post I will discuss the common usage of function decorators, specifically the class property decorator as well as the difference between using the decorator or the class method directly.

Usage

Looks familiar, doesn't it?
The ubiquitous @propery decorator is found everywhere, but how does it actually work?
What are the differences between using @property or using the property() class method directly?

How do decorators even work?

Here's an example of a standard decorator function.

Under the Python hood, the function that calls the decorator (ie. the outer function) gets wrapped with additional code by calling the decorator and passing the outer function as a parameter. The decorator will create a wrapped function with all it's new logic and return it as the value of the outer function.

Understanding the property method

The class property method is a built-in Python function that that allows us to define getter, setter and deleter methods for class attributes, and binds them to the class default magic methods.

def get_my_value(self):
    return self._my_value
my_value = property(get_my_value)

is understood by the Python compiler as

def __get__(self,obj):
    return self.fget(obj)

Essentially, the property() method creates an object that acts as a proxy between the attribute name and the underlying data. It therefore allows us to add custom behavior and validation logic that wouldn't be possible with the default magic methods.

The @property Decorator

As we see above, the property method allows us to overwrite the default magic method and extent its functionality. We've also demonstrated how a decorator wraps functional logic within a new function. When a getter, setter or deleter method is called with the @property decorator, Python translates it into a call to the property() method internally, and creates a property object that wraps the method to a function that can overwrite the default magic methods.

Decorator Benefits

While we have demonstrated that using the @property decorator or property() method are equivalent, the decorator offers a simpler use, and allows the code within the class to be more readable. It is therefore considered best practice and coding convention and the decorator should be used unless there is a specific scenario requirement.

Credits:

https://www.geeksforgeeks.org/python-property-decorator-property/
Blog post header image generator
Code snippet maker

Why prop drilling is bad...

Elchonon Klafter — Tue, 26 Nov 2024 23:39:30 +0000

React is cool.
Actually all frameworks are cool.
They handle the tedious work of coding and allow developers to focus on optimizing workflows and logic, and deliver better code, even faster. However, along with these benefits come new anti-patterns and pitfalls.
Today I will discuss Prop Drilling in React and why it should be avoided.

What is Prop Drilling

Prop drilling is what developers refer to the practice of passing props down through multiple levels of components to reach a deeply nested child component.

Wait. Isn't passing props down to components the correct usage of React?
Correct, however it becomes an anti-pattern when the props are carried down to very deeply nested components simply because of the component structure.

Code Example

// Top-level component
const App = () => {
  const user = { name: 'John Doe', age: 30 };

  return <Parent user={user} />;
};

const Parent = ({ user }) => {
  return <Child user={user} />;
};

const Child = ({ user }) => {
  return <Grandchild user={user} />;
};

const Grandchild = ({ user }) => {
  return <h1>{`Hello, ${user.name}!`}</h1>;
};

export default App;

Why is this a problem?

Complexity and Reusability

In this basic example, because we are passing down the user prop through the intermediate components (Parent, Child), these components must now explicitly declare and pass down the user prop. This causes them to loose the inherent benefit of React that allows components to be reusable.

Tight Coupling

Additionally, this practice makes components dependent on props that they don't actually use. This is especially apparent when making changes to a prop, the cascading changes inside of each intermediate component causes these updates to be time-consuming.

Mistakes Happen

Yes, we all make them sometimes...
As changes to the props requires updating multiple levels of components, this increase the chances of introducing errors into the codebase.

Alternatives

Restructuring Component Tree - Composition vs Inheritance

Prop drilling can occur when using the inheritance technique which allows each component to inherit, duplicate and extend the higher component's props. However, composition allows us to write our components to simply pass down their children without knowing them ahead of time. This eliminates the need to specify the props for each intermediate component.

const App = () => {
  const user = { name: 'John Doe', age: 30 };

  return (
    <Parent>;
      <Child>;
        <Grandchild user={user} />;
      </Child>;
    </Parent>;
  )
};

export default App;

const Parent => (props) {
  return (
    <div className={'parent'}>
     {props.children}
   </div>
  )
};

Context API

Another solution to avoid this anti-pattern is to use the Context API and useContext hook to wrap components that need access to a shared piece of data. However, context in React should ideally only be used for application-wide data, not simply to avoid prop drilling.

Hopefully, this post helped you understand the issues with prop drilling and gave you a better understanding of proper component structuring in React.

You can find even more details in the React documentation.

Arrow Functions => What's wrong with the regular ones?

Elchonon Klafter — Mon, 11 Nov 2024 23:22:43 +0000

If you are expanding your knowledge of JavaScript and wondering why they would ever add Arrow Functions in ECMAScript 2015 (ES6), you are not alone. As I built on my knowledge of the language and its intricacies and quirks, I found myself wondering the same thing. In this post, I will lay out the differences, benefits and reasons why it was added and when you should use it.

Let's talk differences

Before arrow functions were introduced, functions had to be declared in the traditional format as below:

function add(x, y) {
  return x + y;
}

or declared as an expression:

const addFunction = function add(x, y) {
  return x + y;
}

with the introduction of arrow functions, this can be written as:

const addFunction = (x,y) => x + y

Concise Syntax

From the example above, we can easily see that by using an arrow function and leveraging its implicit return feature, the function can be quickly refactored to a single line. The resulting code is more concise, cleaner, and easier to read, resulting in smoother development and faster debugging.

Hoisting

The JavaScript runtime by default will hoist all functions and variable declarations to the top of their scope upon the creation of the Execution Context. For example, within the global scope this ensures that all functions and variables declared will be available to all functions that are later called. However, arrow functions are never hoisted, thereby allowing greater control over the precise location of where a function is executed and the variables that it has access to.

Context

Every time a JavaScript function is executed, it creates an Execution Context which includes information about the environment in which the function is running, including the value of this. While a traditional function gets executed in its own context, an arrow function will always inherit the context of the function which called it.
Using the code below:

class Person {
    constructor(){
        this.name = "George";
        this.greetings = ["Good Morning,","Hello!","Howdy!"];
    }

    printGreetings(){
        this.greetings.forEach(function print(greet){
            console.log(`${greet} ${this.name}`);
        });
    }
}

let person = new Person();
person.printGreetings();

we would get an error saying: Cannot read property 'forEach' of undefined, this is because although the printGreetings function is within the context of the Person class and inherits it's context, nonetheless the forEach function (even though its a built-in JavaScript function) runs in its own context which doesn't contain the this.name property, therefore resulting in a lookup error.

However, an arrow function will never run in its own context, and by rewriting the function above using an arrow function...

printGreetings(){
    this.greetings.forEach((greet) => {
        console.log(`${greet} ${this.name}`);
    });
}

the result will be as expected

Good Morning, George
Hello! George
Howdy! George

Summary

To summarize the benefits of arrow functions; they allow shorter and more concise code; offers implicit return of function block code; doesn't hoist to the top of Execution Context and maintains it's exact location in code; finally, they inherit the context of the function that called it without executing it's own context, allowing a more predictable use of this keyword.

Hopefully this post helped you better understand the differences and benefits of traditional functions verses arrow function, and got you one step further in your JavaScript journey!

Further reading:
Dmitri Pavlutin Blog - Differences between arrow & regular functions
MDN Reference Docs - Arrow Functions