Forem: AMANI Eric

Fading an LED with Arduino

AMANI Eric — Fri, 26 Jan 2024 14:06:27 +0000

In this tutorial I will show you how you can make an LED fade using Arduino.

Materials Needed:

Arduino Board (e.g., uno)
Breadboard and jumper wires
LED
Resistor (270Ω)
USB cable for Arduino
Arduino IDE installed on your computer

Step 1: Set Up the Hardware:

Connect the short leg (cathode) of the LED to GND on the Arduino.
Connect the long leg (anode) of the LED to a resistor (270Ω) and to pin 13 on the Arduino. (Use a jumper wire for it to reach the Arduino pin)

Before we continue, here is how I arranged the components on the breadboard. (Insert an image of the new circuit)

Step 2: Connect your Arduino board to your computer:

Use the appropriate cable for your Arduino board.

Step 3: Writing the Code:

// Fading a single LED
int ledPin = 13; // Pin number for the LED

void setup() {
  pinMode(ledPin, OUTPUT); // Set the LED pin as an output

}

void loop() {
 for (int brightness = 0; brightness <= 255; brightness++) {
    analogWrite(ledPin, brightness);
    delay(5); // Adjust the delay for the desired fade speed
  }

  // Fade out
  for (int brightness = 255; brightness >= 0; brightness--) {
    analogWrite(ledPin, brightness);
    delay(5); // Adjust the delay for the desired fade speed
  }
}

Step 4: Uploading the Code:

Make sure that in your Arduino IDE, the correct board is selected, and click on the upload button.

Your code should be uploaded successfully.

Test Your Fading LED:
Run the uploaded code on your Arduino board, and you should observe the LED fading in and out, creating a smooth fading effect.

Happy coding! ✨

You can what a demo here at the end of this article

Blink multiple LEDs with Arduino

AMANI Eric — Fri, 26 Jan 2024 13:56:10 +0000

In this tutorial, we'll go through the process of blinking multiple LEDs using the Arduino uno R4 WIFI (steps same for most Arduino boards) and a breadboard.

Before we get started check previous article on
how to blink a single LED 👉🏾 here

Materials Needed:

Arduino Board (Ex: uno)
Breadboard and jumper wires(x6)
LEDs (x5)
Resistor (270Ω) (x5)
USB cable for Arduino
Arduino IDE installed on your computer

Step 1: Set Up the Hardware:

Connect the short leg (cathode) of the LED to GND on the Arduino.
Connect the long leg (anode) of the LED to resistor ( 270Ω) and to pin 13 on the Arduino. (Use a jumper wire for it to reach to Arduino pin)
repeat the same for other Arduino digital pins as well 12, 11, 10, 9

You can connect the components differently on breadboard as long as you follow the same circuit its fine.

Step 2: Connect your Arduino board to your computer

Cables can be different depending on Arduino board. Some can use USB and others Type-C cables. Can connect depending on your board.

Step 3: Writing the codes

In your Arduino IDE add those codes.

// Blinking multiple LEDs
int ledPin1 = 13; // Pin number for the LED1
int ledPin2 = 12; // Pin number for the LED2
int ledPin3 = 11; // Pin number for the LED3
int ledPin4 = 10; // Pin number for the LED4
int ledPin5 = 9; // Pin number for the LED5

void setup() {
  pinMode(ledPin1, OUTPUT); // Set the LED1 pin as an output
  pinMode(ledPin2, OUTPUT); // Set the LED2 pin as an output
  pinMode(ledPin3, OUTPUT); // Set the LED3 pin as an output
  pinMode(ledPin4, OUTPUT); // Set the LED4 pin as an output
  pinMode(ledPin5, OUTPUT); // Set the LED5 pin as an output
}

void loop() {
  digitalWrite(ledPin1, HIGH); // Turn the LED1 on
  delay(50); // Wait for 50 milliseconds
  digitalWrite(ledPin1, LOW); // Turn the LED1 off
  delay(50); // Wait for 50 milliseconds
    digitalWrite(ledPin2, HIGH); // Turn the LED2 on
  delay(50); // Wait for 50 milliseconds
  digitalWrite(ledPin2, LOW); // Turn the LED2 off
  delay(50); // Wait for 50 milliseconds
    digitalWrite(ledPin3, HIGH); // Turn the LED3 on
  delay(50); // Wait for 50 milliseconds
  digitalWrite(ledPin3, LOW); // Turn the LED3 off
  delay(50); // Wait for 50 milliseconds
    digitalWrite(ledPin4, HIGH); // Turn the LED4 on
  delay(50); // Wait for 50 milliseconds
  digitalWrite(ledPin4, LOW); // Turn the LED4 off
  delay(50); // Wait for 50 milliseconds
    digitalWrite(ledPin5, HIGH); // Turn the LED5 on
  delay(50); // Wait for 50 milliseconds
  digitalWrite(ledPin5, LOW); // Turn the LED5 off
  delay(50); // Wait for 50 milliseconds
}

Step 4: Uploading the codes

Now, make sure that in your Arduino IDE the correct board is selected and click on the upload button.

Your codes should be uploaded successfully.

If the steps above were followed, the led will be blinking every one second 🎉

You can read more on the article and check demo 👉🏾here

Blinking an LED with Arduino

AMANI Eric — Thu, 25 Jan 2024 14:33:23 +0000

Blinking an LED is a fundamental project for Arduino enthusiasts. In this tutorial, we'll go through the process of blinking an LED using the Arduino uno R4 WIFI (steps same for most Arduino boards) and a breadboard. Let's get started!

Materials Needed:

Arduino Board (Ex: uno)
Breadboard and jumper wires
LED
Resistor (270Ω)
USB cable for Arduino
Arduino IDE installed on your computer

Step 1: Set Up the Hardware:

Connect the short leg (cathode) of the LED to GND on the Arduino.
Connect the long leg (anode) of the LED to resistor ( 270Ω) and to pin 13 on the Arduino.

You can connect the components differently on breadboard as long as you follow the same circuit its fine.

Step 2: Connect your Arduino board to your computer

Cables can be different depending on Arduino board. Some can use USB and others Type-C cables. Can connect depending on your board.

Step 3: Writing the codes

In your Arduino IDE add those codes.

// Blinking a single LED
int ledPin = 13; // Pin number for the LED

void setup() {
  pinMode(ledPin, OUTPUT); // Sets the LED pin as an output
}

void loop() {
  digitalWrite(ledPin, HIGH); // Turn the LED on
  delay(1000); // Wait for 1 second
  digitalWrite(ledPin, LOW); // Turn the LED off
  delay(1000); // Wait for 1 second
}

Step 4: Uploading the codes

Now, make sure that in your Arduino IDE the correct board is selected and click on the upload button.

Your codes should be uploaded successfully.

If the steps above were followed, the led will be blinking every one second 🎉

You can read more on the article 👉🏾here

If you liked this post, you might as well like to checkout on fading an LED.
Fading an LED

A fatal error occurred: Unable to verify flash chip connection (No serial data received.)

AMANI Eric — Wed, 10 Jan 2024 11:49:50 +0000

Recently, I acquired an ESP32-S3 UNO, and upon receiving it, I proceeded to test its functionality. Although it powered on normally, I encountered an issue while attempting to upload my code, receiving the error message: "A fatal error occurred: Unable to verify flash chip connection (No serial data received.)"

Assuming a potential fault with one of the boards, I tested a second, identical board, only to encounter the same error.

This led me to conclude that the issue might lie elsewhere.

I experimented with various Type-C cables, connected to different ports, and ensured that the correct board was selected in the Arduino IDE. Despite these efforts, the issue persisted.

Numerous solutions found online proved unhelpful. However, during my research, I came across a discussion on the Arduino Forum related to a similar issue Arduino Forum Link. While the forum provided valuable insights, none of the suggested solutions seemed to work. Nonetheless, it's worth exploring these resources as your situation might differ.

Importantly, I want to note that there was no issue with my codes. I had a simple blinking LED program as follows:


int ledPin = 12;


void setup() {
pinMode(ledPin, OUTPUT);

}

void loop() {

digitalWrite(ledPin, HIGH);
delay(200);
digitalWrite(ledPin, LOW);
delay(200);

}

In my continued troubleshooting efforts, I discovered a resolution that worked:

I changed the upload speed in the Arduino IDE tools settings from 921600 to 115200 and it worked.

Happy coding! 🎉

You can also read article on my blog and feel free to drop questions or issues if you need help. 👉🏽 A fatal error occurred: Unable to verify flash chip connection (No serial data received.)

Mastering Parallel Execution with async/await in JavaScript (Node.js) for Beginners

AMANI Eric — Tue, 25 Jul 2023 14:47:26 +0000

Asynchronous programming can be intimidating for beginners, but fear not! JavaScript comes to the rescue with its async/await syntax, offering a more approachable way to handle asynchronous tasks.

In this beginner-friendly blog post, we will demystify parallel execution using async/await in a Node.js environment. Let's dive in and unlock the power of running tasks concurrently with JavaScript!

Embracing the Simplicity of async/await:

Async/await, introduced in ECMAScript 2017, allows us to write asynchronous code in a more intuitive and synchronous-like manner. It simplifies the handling of promises and asynchronous operations, making our code easier to read and understand.

Unlocking Parallel Execution:

To unleash the potential of async/await in parallel execution, we can tap into JavaScript's Promise API. A handy method called Promise.all() comes to the rescue, enabling us to run multiple tasks concurrently. Let's explore a beginner-friendly example:

async function runTasksInParallel() {
  const task1 = asyncTask1();
  const task2 = asyncTask2();
  const task3 = asyncTask3();

  await Promise.all([task1, task2, task3]);

  console.log('Congratulations! All tasks completed successfully.');
}

runTasksInParallel();

In the example above, asyncTask1(), asyncTask2(), and asyncTask3() represent individual asynchronous functions. By utilizing Promise.all(), we can await the completion of all tasks concurrently, resulting in better performance.

Navigating Error Handling:

When working with parallel execution, it's crucial to handle errors effectively. With async/await, we can use the trusty try/catch statement to gracefully manage errors. Let's enhance our previous example to include error handling:

async function runTasksInParallel() {
  try {
    const task1 = asyncTask1();
    const task2 = asyncTask2();
    const task3 = asyncTask3();

    await Promise.all([task1, task2, task3]);

    console.log('Congratulations! All tasks completed successfully.');
  } catch (error) {
    console.error('Oops! An error occurred while running tasks:', error);
  }
}

runTasksInParallel();

By encapsulating the entire async function within a try block and catching any errors in the catch block, we ensure that any errors during the parallel execution are handled gracefully.

Unleashing Performance with Parallelism:

Parallel execution can significantly boost performance, especially when dealing with time-consuming operations like making multiple API calls or processing large amounts of data. By harnessing the power of async/await and parallel execution, we can tap into JavaScript's full potential for efficient and optimized code execution.

Understanding Promise.allSettled():

When working with multiple asynchronous tasks, you might come across scenarios where you need to know when all the tasks have settled, regardless of whether they succeeded or failed. JavaScript provides a helpful method called Promise.allSettled() that allows you to handle such situations. Let's explore it in detail:

The Promise.allSettled() method takes an iterable of promises and returns a single promise that is fulfilled with an array of promise settlement results. These settlement results provide information about each individual promise, indicating whether they were fulfilled or rejected.

const promises = [promise1, promise2, promise3];

Promise.allSettled(promises)
 .then((results) => {
   results.forEach((result, index) => {
     if (result.status === 'fulfilled') {
       console.log(`Promise ${index + 1} was fulfilled with value:`, result.value);
     } else if (result.status === 'rejected') {
       console.log(`Promise ${index + 1} was rejected with reason:`, result.reason);
     }
   });
 });

In the example above ☝🏾, promises represents an array of asynchronous tasks as promises. By using Promise.allSettled(), we can wait for all the promises to settle. The resulting array results contains settlement information for each promise, including the status (either "fulfilled" or "rejected") and the corresponding value or reason.

Congratulations ✨, you've embarked on a journey to master parallel execution with async/await in JavaScript! With async/await's simplicity and the power of Promise.all(), you're now equipped to write cleaner, more readable, and high-performing code.

As you continue your coding adventures in Node.js, remember to embrace parallel execution to unlock new levels of efficiency and deliver outstanding user experiences. Happy coding! 🎉

Why you should use Clamp over Media Queries

AMANI Eric — Tue, 25 Jul 2023 14:37:54 +0000

In the ever-evolving landscape of web design, responsiveness has become a key consideration. As a beginner, you may have heard of media queries as the go-to solution for achieving responsiveness. However, there's an emerging technique that offers a more streamlined approach: clamp.

In this article, we'll delve into the benefits of using clamp over media queries, providing clear examples that will empower you to take your responsiveness game to the next level.

Unleashing Responsive Magic:

Media queries can be complex, requiring multiple lines of code to handle various screen sizes. Using Clamp is a game-changing technique with a simple syntax that condenses your code and offers limitless potential. Let's explore a practical example to witness Clamp's magic in action:



/* Media Queries */
@media screen and (max-width: 768px) {
    .element {
        font-size: 14px;
    }
}

/* Clamp */
.element {
    font-size: clamp(12px, 4vw, 16px);
}

By using clamp ☝🏾 , we specify a range of acceptable values for the font size. The 4vw unit allows the font size to scale proportionally with the viewport width. With just a single line of code, we achieve a fluid and responsive typography that adapts seamlessly to different screen sizes.



h1 {
    font-size: clamp(24px, 6vw, 48px);
}

Dynamic Element Sizing:

While media queries are suitable for handling layout changes, they often require predefined breakpoints, leaving room for inconsistencies. Clamp offers a more flexible approach to sizing elements by allowing you to define a range. Let's explore a scenario:



.container {
    width: clamp(300px, 50%, 600px);
}

By using clamp, the container width is set to span 50% of the available space but never exceeding 600 pixels or falling below
300 pixels. This ensures the element maintains a balanced and visually pleasing size, irrespective of the viewport dimensions.

Browser Support

Clamp has gained significant traction in the web development community. With solid support from major browsers, including Chrome, Firefox, Safari, and Edge (source: Can I use), clamp has become a go-to solution for achieving responsiveness. Its widespread adoption showcases its effectiveness in simplifying design and enhancing user experiences.
Check full report here

Harmonious Blend:

While clamp proves to be a game-changer in responsiveness, it doesn't render media queries obsolete. In fact, these techniques complement each other perfectly. Media queries excel in handling broader layout changes, while clamp enhances the finer details.

By employing a hybrid approach, you can create a responsive design that covers both structural and visual aspects.

Responsive web design is no longer a luxury; 💎 it's an essential aspect of modern web development. As a beginner, embracing Clamp as an alternative to media queries can unlock a world of possibilities.

By simplifying your code, achieving fluid typography, enabling dynamic element sizing, and leveraging a combined approach, you'll be on your way to crafting exceptional user experiences that seamlessly adapt to any device. So, why settle for static designs when you can embrace the power of clamp and elevate your responsiveness to new heights?

You can also read article on my blog and feel free to drop questions or issues if you need help. 👉🏽 Why you should use Clamp over Media Queries

How to expose PostgreSQL connection in ubuntu

AMANI Eric — Wed, 11 Jan 2023 08:08:46 +0000

If you have a PostgreSQL database instance running on an Ubuntu server, you might want
to access it from outside the server.
In this article, I'm going to show you how you can do it.

The default Postgres connection port is usually 5432. We are going to expose our connection through this port.
You can use your other port if not using the default one.

Allow Postgres port in the firewall (5432 in our case)

sudo ufw allow 5432/tcp

Open your Postgres config file

sudo nano /etc/postgresql/<postgres_version>/main/pg_hba.conf

Notice that I used ../14/.. . That's because I have PostgreSQL version 14 installed. Change it to your installed version

It will open your PostgreSQL config file.

By default, the allowed address to access the Postgres connection is 127.0.0.1/32.
That means you can only be connected if you are on the same server.

We have to change that since we want the connection to be public.

Change the IP address from 127.0.0.1:32 => 0.0.0.0/0

What we did is allow any IP address at any port to access ur connection.

Now you can connect to the database from anywhere.

N.B: Changing from 127.0.0.1/32 in your configs to 0.0.0.0/0 means you are allowing any device from any.
This is insecure. If you want to be more secure, you can change it from 127.0.0.1/32 to your_trusted_ip/your_trusted_ip_port

Construct a connection string like this and connect it to your database.

👉🏽 postgresql://[user[:password]@][our_server_ip][:our_postgres_server_ip][/dbname]

You can also test the connection with PGAdmin which is a powerful Postgres client.

You should be able to access your database 🎉

How to integrate Google AdSense in NextJS

AMANI Eric — Tue, 10 Jan 2023 08:54:57 +0000

If you are having a blog, you might want to monetize it. Adding ads to your blog is among the effective ways to monetize it.

In this article, I will show you how you can integrate Google AdSense into your NextJs app.

How do I get my site approved for google AdSense?

To have your site approved for showing Google ads, there are steps to follow carefully.

You can check these eligibility criteria here carefully to avoid being rejected
in the first place.

Pro Tip: Before you request Google Adsense approval, make sure your website has at least 10 dynamic articles (content should be changing regularly) and a proper domain name.

If your site is eligible for google AdSense, you will get a response from google on how to get started.

It takes a few days to get approved but in some cases, it might take between 2 and 4 weeks.

If your site is approved for google AdSense, follow the following steps to integrate it into your NextJs app
and start showing ads.

Add your client in the NextJs _document script

pages/_document.tsx 👇🏽


import { Html, Head, Main, NextScript } from 'next/document';
import Script from 'next/script';

export default function Document() {
  return (
    <Html lang="en">
      <Head>
        <Script
          async
          src={`https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=${process.env.NEXT_PUBLIC_GOOGLE_ADS_CLIENT_ID}`}
          strategy="lazyOnload"
          crossOrigin="anonymous"
        />
      </Head>
      <body>
        <Main />
        <NextScript />
      </body>
    </Html>
  );
}

change NEXT_PUBLIC_GOOGLE_ADS_CLIENT_ID. to the env variable containing your ads client id (ca-pub-*********)

Create an ad banner component

components/AdBanner.tsx 👇🏽

import { useEffect } from 'react';

const AdBanner = (props) => {
  useEffect(() => {
    try {
      (window.adsbygoogle = window.adsbygoogle || []).push({});
    } catch (err) {
      console.log(err);
    }
  }, []);

  return (
    <ins
      className="adsbygoogle adbanner-customize"
      style={{
        display: 'block',
        overflow: 'hidden',
      }}
      data-ad-client={process.env.NEXT_PUBLIC_GOOGLE_ADS_CLIENT_ID}
      {...props}
    />
  );
};
export default AdBanner;

Get Google ads block codes from your adsense dashboard.

Notice that we are using the default code from the ad banner component above ☝🏾

adsense dashboard amanieric.com

let's try with Display ads .

click on display ads card

Choose your ad layout (depends on the place you want to place it)

Copy these codes (Ignore the rest. we already have them defined in our banner component) and click done

Import the ad banner component anywhere your want this kind of ad to show and ad the codes copies above as props to the ad banner.

Our ad banner component imported will look like this 👇🏽

       AdBanner
          data-ad-slot="7434970023"
          data-ad-format="auto"
          data-full-width-responsive="true"
        />

Deploy the changes and on the hosted version of your app , the add banner will be showing the ad where your placed the component ✨

Feel free to drop any issue in the comments if you need help

You can also read article on my blog and feel free to drop questions or issues if you need help. 👉🏽 How to integrate Google AdSense in NextJS

Why your web app should have ssl certificate

AMANI Eric — Tue, 10 Jan 2023 08:40:11 +0000

In this article, I will show you how you can add a free SSL certificate to your Nginx server with Certbot.

Before we start, let's understand what SSL is.

What is SSL?

SSL(Secure Socket Layer) is a protocol for establishing authenticated and encrypted links/connections between connected computers.

What is SSL certificate and why do we need it?

An SSL certificate (also known as a TLS or SSL/TLS certificate) is a digital document that binds the identity of a website to a cryptographic key pair consisting of a public key and a private key.

The public key, included in the certificate, allows a web browser to initiate an encrypted communication session with a web server via the TLS and HTTPS protocols. The private key is kept secure on the server and is used to digitally sign web pages and other documents (such as images and JavaScript files)
(source: ssl.com )

Reasons your web page/application should have an SSL certificate:

It protects you and your web page/app users against hackers.

Since the connection is secured in a way that the information from your app's visitors' devices and your app is encrypted, it's hard for a hacker to know the information being shared.

When you buy something online, you share your payment information with the site you are using (credit cards, PayPal,…).

Ex: In this case, if the site is not using SSL, it's easier for a hacker to grab the information being shared.
But in the other case where you are using a secure connection (SSL), even though the hacker can be able to intercept the connection, he can't be able to know the information being shared since it's encrypted.

Increases trustworthy in your users

Users trust your page/app more since they are confident that the information they share with or
through it is secure.

Improves your app's SEO

It's no secret that having an SSL certificate ranks your site higher in search engines like Google.
Some browsers like chrome block unsecure apps by default from being accessed (to protect users' online privacy)and that can lead to poor performance for your app and poor SEO.

You can learn more about SSL by using these resources.

ssl.com

Assign a free SSL certificate to an nginx server with certbot

AMANI Eric — Tue, 10 Jan 2023 08:32:07 +0000

In this article, I will show you how you can add a free SSL certificate to your Nginx server with Certbot.

Before we start, check my previous article to understand more about SSL, and check here about serving a static app with Nginx.

What is certbot?

Certbot is an open-source automated software that generates Let's Encrypt Certificates. SSL
certificates are provided free of cost by the Internet Security Research Group(ISRG).

Let's get started 💎

Considering we already have our app being served by Nginx on our server, we can proceed to install certbot first.

Before you get started, I assume that.

You are familiar with Nginx
You have Nginx running on an ubuntu Linux server

Install certbot

$ apt-get update 
$ sudo apt-get install certbot 
$ apt-get install python-certbot-nginx

Get SSL/TLS certificate

$ sudo certbot --nginx -d example.com

Here example.com ☝🏾 is referring to the domain Nginx is using to serve our app.

If successful, you should get a response like below 👇🏽

Open the browser and visit your app.
It should be using HTTPS with a valid SSL/TLS certificate ⚡️

Also check 👉🏽 Serve a static app with Nginx

Serve a static app with nginx

AMANI Eric — Sun, 08 Jan 2023 18:32:30 +0000

What is Nginx?

NGINX is open source software for web serving, reverse proxying, caching, load balancing, media streaming, and more.

It started out as a web server designed for maximum performance and stability. In addition to its HTTP server capabilities, NGINX can also function as a proxy server for email (IMAP, POP3, and SMTP) and a reverse proxy and load balancer for HTTP, TCP, and UDP servers.

In this article I'm going to show you how you can serve a static app like react using nginx.

Let's get started 🚀

1. Install Nginx (Ubuntu)



sudo apt update
sudo apt install nginx

2. Deploy your react app

Clone your react app



git clone https://github.com/<your username>/<your react app repo>.git

Install packages



sudo yarn install

Build the app



sudo yarn build

3. Create an Nginx configuration file



cd /etc/nginx/sites-available



sudo nano react.conf

Paste this codes




server {
    listen 80;
    server_name your_IP_or_Domain;
    root /home/username/path_to_your_react_app/build;
    index index.html index.htm;
    location / {
        try_files $uri/index.html=404;
}

Create an nginx virtual host file.
we are going to do this by creating symlink to our config file for nginx to recognize it



sudo ln -s /etc/nginx/sites-available/react.conf  /etc/nginx/sites-enabled

Now that we are done with our configurations, let's test it.
To test if the configurations have no errors we run the command below.



sudo nginx -t

if successful, you should see this in your terminal 🦾

let's test our static app.

this restart our nginx service



sudo service nginx restart

Then open your browser and visit your_ip or domain as used in
our config file.

You should see the app running ✨

Some helpful resources

can check the article here as well

Task-Force week five experience

AMANI Eric — Sun, 03 Oct 2021 09:59:22 +0000

As today marks the end of the fifth week in Task-Force, I'm going to share with you the experience so far.

This week involved a lot of activities and there were many things to learn.

The session on Thursday was the most amazing as I got to learn about Agile Methodology deeply.

I was not my first time using/knowing about Agile methodology but I found out that there is more to Agile Methodology than what I knew before.

We played short games to help us understand Agile Methodology better, where some teammates were acting as SCRUM Masters, Developers, Product Owner, Client and so..on.

This helped me to understand how each party plays a role in Agile Methodology and also understand its best practices.

This was a long day but fruitful. I enjoyed every moment of the Thursday session.

During this week, we also worked on some coding challenges.
Coding challenges can be fun and also helpful as you are learning and developing your problem-solving skills.

In programming, there are many alternatives to a solution but optimization of your solution also matters.
Coding challenges help you on this. It's good if you start a week with coding challenges to refresh your mind :)

Coming to Friday, we had to brainstorm and come up with an idea for our final project. The idea had to be solving a real problem and had to be unique.

After a brief discussion, we came up with ideas for our project and chose the best one to work on.

Generally, this week was amazing but Thursday was another thing. It was super amazing. I can't wait to see how next week is going to be like :)