Forem: Rowida

upgrade node version

Rowida — Tue, 13 Aug 2024 11:51:37 +0000

Upgrading Node.js from version 14 to version 18 in a Dockerized React project involves updating the Node.js version in your Dockerfile and ensuring that your project dependencies are compatible with the new Node.js version. Here are the steps to do this:

Update Dockerfile: Modify your Dockerfile to use Node.js version 18. Replace the existing FROM line with one that specifies Node.js 18.

   # Use the official Node.js 18 image from the Docker Hub
   FROM node:18

   # Set the working directory
   WORKDIR /app

   # Copy package.json and package-lock.json files
   COPY package*.json ./

   # Install dependencies
   RUN npm install

   # Copy the rest of the application code
   COPY . .

   # Build the React application
   RUN npm run build

   # Expose the application port
   EXPOSE 3000

   # Start the application
   CMD ["npm", "start"]

Rebuild the Docker Image: After updating the Dockerfile, rebuild your Docker image to use the new Node.js version.

   docker build -t your-image-name .

Run the Updated Container: Once the image is rebuilt, run the container using the new image.

   docker run -p 3000:3000 your-image-name

Check Dependencies: Ensure that your project dependencies are compatible with Node.js 18. Update any dependencies if necessary. You can check for outdated packages and update them using npm:

   npm outdated
   npm update

If there are major version changes in your dependencies, you might need to manually update them in package.json and resolve any breaking changes.

Test Your Application:
Thoroughly test your application to make sure everything works correctly with Node.js 18.
Update CI/CD Pipelines (if applicable):
If you are using CI/CD pipelines, make sure to update the Node.js version in your CI/CD configuration files (e.g., GitHub Actions, CircleCI, etc.) to use Node.js 18.

Here's an example of updating a GitHub Actions workflow to use Node.js 18:

name: CI

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node-version: [18]

    steps:
      - uses: actions/checkout@v2
      - name: Use Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v2
        with:
          node-version: ${{ matrix.node-version }}
      - run: npm install
      - run: npm run build --if-present
      - run: npm test

By following these steps, you can successfully upgrade your Dockerized React project from Node.js version 14 to version 18.

Someone is getting better at Miro board

Rowida — Sat, 11 May 2024 09:42:31 +0000

buffering...

Functional Programming with JavaScript chapter 3 Notes

Rowida — Tue, 25 Apr 2023 09:17:37 +0000

JavaScript supports functional programming because JavaScript functions are first-class citizens.

What is first-class citizens?

First-class citizens or as called first-class object means that functions can do the same things that variables can do.

It can be stored whether in a variable, array or object.
And that functions can be passed as an argument to the functions and be returned by the function.

for a better tracking of the following examples' output,I am using a h4 with id equals ch3.

<div class="body" style=" height: 1000px; ">
    <h1 style="color: brown; align-items: center; text-align: center;" class="mt-5">Learning react</h1>
    <h4 class="display-6 text-center mt-4" id="ch3"></h4>
</div>

<script src="./ch3.js"></script>

let content = document.getElementById("ch3");

1- Store function in a variable.

We can declare functions with the var or let keyword the same way you can declare strings, numbers, or any other variables:

var log = function (msg) {
  console.log(msg);
  content.innerText += `\n  ${msg}`;
};

log("In JavaScript functions are variables");
// In JavaScript, functions are variables

With ES6, we can write the same function using an arrow function

// using an arrow function

var log = (msg) => {
  console.log(msg);
  content.innerText += `\n  ${msg}`;
};

log("In JavaScript functions are variables using an arrow function");

2- Store functions in objects

Since functions are variables, we can add them to objects:

// Since functions are variables, we can add them to objects:
const obj = {
  msg: "adding functions to objects",
  message: "They can be added to objects like variables",
  log(msg) {
    console.log(msg);
    content.innerText += `\n  ${msg}`;
  },
};
obj.log(obj.msg);
obj.log(obj.message);

In the previous example we store a function in a variable called log.

3- Store functions in arrays.

We can also add functions to arrays in JavaScript

// Since functions are variables, we can add them to arrays:

const arr = [
  "adding functions to arrays",
  (log) => console.log(log),
  "like variables",
  (msg) => {console.log(msg);
    content.innerText += `\n  ${msg}`;
},
  (test) => {
    console.log(test);
    content.innerText += `\n  ${test}`;
  },
  "They can be inserted into arrays",
];

arr[4](arr[5]);
arr[1](arr[0])
arr[3](arr[2])
// They can be inserted into arrays
// like variables

4- Pass functions as arguments.

Functions can be sent to other functions as arguments.

const insideFn = logger => logger("They can be sent to other functions as arguments");
insideFn(log);

5- Return Functions by the function.

Functions can be also returned from other functions, just like variables:

const createScream = function(logger) { 
    // getting logger functions as a parameter
    console.log('new func return');
    return function(msg){ 
        // getting a normal msg text as an argument
        logger(`${msg} from return function  !!!`);
    }
}

Using ES6 syntax, we could describe the same createScream

const createScreamarrow = logger => message =>
logger(message.toUpperCase() + "!!!")

Context Manager With Files In Python

Rowida — Sat, 26 Nov 2022 18:33:20 +0000

What is a Context Manager?

Context manager is commonly used with reading and writing files to assist in conserving system memory and improve resource management by ensuring that each process holds its resources while executing.

It's an object, that is notified when a context starts and ends, of a class that implements the 2 magic methods __enter__ and __exit__ and any other methods if needed.

For example: when a context manager ends, the object file is closed.

with open('test_ch30.txt' , 'w+') as file:
    file.write('Blew the lid of ur life')

 # the open file has automaticlly been clossed

Opening a file using with statement ensures that File descriptor are closed automatically.

How `with` statment implements a context manager?

1- When an object is called with a with statment, the
interpreter invokes the __eneter__ method ,which is used to
call and performe the setup code required and needed for the
process yo be excuted, before the with statment.

2- When the with statments ends, the interpreter invokes the __exit__ method .

Illustartion :

What's required to implement a contect manager class?

class ContextManager(object):
    """docstring for ContextManager"""
    def __init__(self):
        pass

    def __enter__(self):
        print("__enter__()")
        # optionaly return an obj
        return "an instance"

    def __exit__(self , exc_type , exc_val , traceback):
        print("__exit__ with " , exc_val if exc_val else ' nope')


with ContextManager() as e:
    print("is a " , e)

Multiple context managers


with open('test_ch30.txt') as input_file, open('test_ch77.txt', 'w') as output_file:
    # do something with both files.
    # e.g. copy the contents of input_file into output_file
    for line in input_file:
        output_file.write(line + '\n')

# It has the same effect as nesting context managers:
with open('test_ch30.txt') as input_file:
    with open('test_ch77.txt', 'w') as output_file:
        for line in input_file:
            output_file.write(line + '\n')

Manage Resources

class File():
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
    def __enter__(self):
        self.open_file = open(self.filename, self.mode)
        return self.open_file
    def __exit__(self, *args):
        self.open_file.close()


for _ in range(10000):
    with File('test_ch30.txt', 'w') as f:
        f.write('foo')

ManageFile class follow.

ManageFile class follow/adhere the context manager protocole and support the with statment Code link

Access "file name" From Origin 'null' has been Blocked by cors Policy: Cross Origin requests are only supported for Pro

Rowida — Mon, 24 Jan 2022 21:44:40 +0000

whenever I try to import files in JS&TS I got this error.

Solutions :

Open the CMD, globally execute that command line.

npm install anywhere -g

To run the server

anywhere

and then, run your server at https://192.168.1.8:8001/

Context Managers with `with` statement in python

Rowida — Mon, 11 Oct 2021 02:46:01 +0000

What is a Context Manager?

It's an object, that is notified when a context or a block of code starts and ends, of a class that implements the 2 magic methods __enter__ and __exit__ and any other methods if needed.

For example: when a context manager ends, the object file is closed.

with open('test_ch30.txt' , 'w+') as file:
    file.write('Blew the lid of ur life')

 # the open file has automatically been closed

Context manager is commonly used on reading and writing files to assist in conserving system memory and improve resource management by ensuring that each process holds its resources while executing.

Opening a file using with statement ensures that File descriptor are closed automatically.

How `with` statment implements a context manager?

1- When an object is called with a with statement, the
interpreter invokes the __enter__ method ,which is used to
call and perform the setup code required and needed for the
process to be executed, before the with statement.

2- When the with statements ends, the interpreter invokes the __exit__ method .

Illustration :

What's required to implement a contect manager class?

class ContextManager(object):
    """docstring for ContextManager"""
    def __init__(self):
        pass

    def __enter__(self):
        print("__enter__()")
        # optional return an obj
        return "an instance"

    def __exit__(self , exc_type , exc_val , traceback):
        print("__exit__ with " , exc_val if exc_val else ' nope')


with ContextManager() as e:
    print("is a " , e)

Multiple context managers


with open('test_ch30.txt') as input_file, open('test_ch77.txt', 'w') as output_file:
    # do something with both files.
    # e.g. copy the contents of input_file into output_file
    for line in input_file:
        output_file.write(line + '\n')

# It has the same effect as nesting context managers:
with open('test_ch30.txt') as input_file:
    with open('test_ch77.txt', 'w') as output_file:
        for line in input_file:
            output_file.write(line + '\n')

Manage Resources

class File():
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
    def __enter__(self):
        self.open_file = open(self.filename, self.mode)
        return self.open_file
    def __exit__(self, *args):
        self.open_file.close()


for _ in range(10000):
    with File('test_ch30.txt', 'w') as f:
        f.write('foo')

ManageFile class follow.

ManageFile class follow/adhere the context manager protocol and support the with statement Code link

Which Implementation Should You Use for Stacks In Python?

Rowida — Wed, 06 Oct 2021 06:40:48 +0000

Python Stacks and Threading

Let me just recap what I've read about how to implement Stacks in python so far.

There are 2 options to create a stack in python whether using lists or deques and both of them behave differently if your program has threads.

It's a better sweet not to use lists to implement Stacks or any data structure that can be accessed by multiple threads as lists is not thread-safe. List can potentially have memory reallocation issues and it makes you build the entire functionality of the stacks on your own.

deaues is a thread-safe more than list, even if it's more complex than lists, according to queue class documentation, it clearly states that both the .append()and .pop() operations are atomic, meaning that they won’t be interrupted by a different thread.

So, while it’s possible to build a thread-safe Python stack 
using a deque, doing so exposes yourself to someone misusing
 it in the future and causing race conditions.

For this use LifoQueue from queue module.

LifoQueue is designed to be fully thread-safe. All of its methods are safe to use in a threaded environment.

from queue import LifoQueue
myStack = LifoQueue()

myStack.put('a')
myStack.put('b')
myStack.put('c')

myStack


myStack.get()

myStack.get()

myStack.get()


# myStack.get() <--- waits forever
myStack.get_nowait()

In notes :

Use a deque if you’re not using threading.
If your program has threads, then you should use a LifoQueue
The interface of both list and deque are the same ,yet deque doesn’t have memory allocation issues, which makes deque the best choice for your non-threaded Python stack.

Notes on Thread and threading module in python

Rowida — Tue, 05 Oct 2021 06:05:16 +0000

This post encompasses some notes about thread and
Threading module in python, that I used as a quick recap.

What is Thread.

Thread Is a basic unit of CPU Utilization, the smallest unit of processing that can be performed in OS and an entity within a process. One process can have Multiple threads.

What thread contains?

It contains specific information in a Thread Control Block (TCB) such as :

Thread ID which is assign to every new thread.
Stack pointer that contains the local variables under thread’s scope.
Program counter Or Register that contains the address of the current instruction being executed by the Thread.
Parent Process Pointer to point to Process control block
(PCB) of the parent process that this thread lives on.

Threading module provides a very simple and intuitive API for implementing multiple threads. Thread in this module encapsulates threads and provide an interface to work with them.

Python has a complicated relationship with threading thanks to its GIL,

To create a new thread is by calling threading.Thread


from threading import Thread

def foo():
    print("Hola Hola")

f1 = Thread(target = foo)
# the thread will never be executed unless `start` is called
f1.start()

Note Start will run and terminated. Calling thread_name.start again will cause a RuntimeError

You can find the code in the following repository, It's a chapter within a repository for the book Python for professional Book repo.

Forem: Rowida

upgrade node version

Someone is getting better at Miro board

Functional Programming with JavaScript chapter 3 Notes

1- Store function in a variable.

2- Store functions in objects

3- Store functions in arrays.

4- Pass functions as arguments.

5- Return Functions by the function.

Context Manager With Files In Python

What is a Context Manager?

How with statment implements a context manager?

What's required to implement a contect manager class?

Multiple context managers

Manage Resources

ManageFile class follow.

Access "file name" From Origin 'null' has been Blocked by cors Policy: Cross Origin requests are only supported for Pro

Context Managers with `with` statement in python

What is a Context Manager?

How with statment implements a context manager?

What's required to implement a contect manager class?

Multiple context managers

Manage Resources

ManageFile class follow.

Which Implementation Should You Use for Stacks In Python?

Python Stacks and Threading

Notes on Thread and threading module in python

What is Thread.

What thread contains?

To Read:

How `with` statment implements a context manager?

How `with` statment implements a context manager?