DEV Community: Code_Jedi

12 Obscure Ethical Hacking Techniques for Bug Bounties

Code_Jedi — Sat, 14 Oct 2023 08:24:33 +0000

Bug bounty programs have revolutionized the way companies approach cybersecurity. These initiatives invite ethical hackers to discover and report vulnerabilities in exchange for monetary rewards. As these programs become increasingly popular, the competition among hackers to find and report bugs grows fiercer. To stand out and claim those coveted bounties, it's essential to delve into obscure ethical hacking techniques. In this article, we will explore some lesser-known strategies that can help you get ahead in the bug bounty game.

1. Subdomain Enumeration

While subdomain enumeration might not be obscure to seasoned hackers, it is often overlooked by beginners. Many organizations have a complex web of subdomains that are less frequently monitored and easier to exploit. Using tools like Amass, Sublist3r, or SubFinder can help you discover these overlooked domains. By identifying subdomains and performing reconnaissance on them, you can find vulnerabilities that others might miss.

2. API and Mobile Application Testing

Many bug bounty hunters primarily focus on web applications, but mobile apps and APIs are equally lucrative targets. Mobile applications often have weak authentication, insecure data storage, or other vulnerabilities that are overlooked. By delving into the world of mobile app security, you can find unique bugs like insecure API endpoints, sensitive data exposure, or even server-side issues.

3. Fuzzing Techniques

Fuzzing involves feeding an application with a large number of random or semi-random data in an attempt to crash it or discover vulnerabilities. This technique is commonly used, but there are obscure avenues to explore within fuzzing, such as differential fuzzing and protocol-specific fuzzing. Differential fuzzing compares the behavior of two or more similar implementations of a protocol, aiming to find inconsistencies and potential vulnerabilities. Protocol-specific fuzzing targets specific protocols like DNS, DHCP, or SMB, which are often overlooked by other hackers.

4. Web Caching and CDN Exploitation

Content Delivery Networks (CDNs) and web caching systems are designed to optimize website performance, but they can also introduce security risks. By exploring how these systems interact with the origin server and handling cache-related headers, you may find cache poisoning or data leakage vulnerabilities. These issues can be obscure but have a significant impact on web application security.

5. Bluetooth Hacking

With the increasing use of IoT devices, Bluetooth hacking presents an emerging area for bug hunting. Bluetooth Low Energy (BLE) devices can have vulnerabilities that range from weak encryption to device impersonation. Researchers who dive into this realm can find obscure but high-value bugs that lead to unauthorized access, data theft, or even control over IoT devices.

6. Protocol Fuzzing

Protocol fuzzing is a technique where an attacker sends a large amount of random or unexpected data to an application to detect vulnerabilities. This method is especially useful when dealing with applications that use custom or lesser-known protocols. By injecting malformed data and analyzing the application's response, you can uncover unexpected behavior or vulnerabilities that might go unnoticed through traditional testing methods.

7. DOM Clobbering

DOM Clobbering is a method to manipulate the Document Object Model (DOM) of a web page by overwriting objects and properties. This technique can help you find cross-site scripting (XSS) vulnerabilities that might not be easily discoverable using traditional payloads. By carefully manipulating the DOM, you can provoke the application into executing your malicious code.

8. Binary Analysis

While binary analysis is a more advanced technique, it can be incredibly valuable for bug bounty hunters who target native applications and firmware. Reverse engineering binary files allows you to uncover vulnerabilities and exploits in areas where source code isn't readily accessible. This method is particularly useful for finding security issues in embedded systems, IoT devices, and proprietary software.

9. Protocol-Level Attacks

Many bug hunters focus on web application security, but protocol-level attacks can be highly rewarding. For example, by understanding and manipulating network protocols, you can find vulnerabilities in networked devices and services. Protocol-level attacks might include DNS cache poisoning, ARP spoofing, or IP fragmentation attacks, all of which can lead to critical security flaws.

10. Timing Attacks

Timing attacks are subtle and powerful methods to exploit vulnerabilities by exploiting the time it takes for an application to respond to specific inputs. These attacks can reveal cryptographic vulnerabilities, password hashes, and sensitive information. Timing attacks are often overlooked, making them an obscure but effective approach to uncovering security weaknesses.

11. Protocol Reverse Engineering

Understanding and reverse engineering custom network protocols can open doors to uncovering obscure security flaws. This is especially useful in scenarios where you are dealing with non-standard communication protocols that may be unique to certain applications or services. By gaining insight into how these protocols work, you can better identify weaknesses and vulnerabilities.

Conclusion

The world of ethical hacking is constantly evolving, and to stay ahead in the bug bounty game, it's crucial to explore lesser-known techniques and vulnerabilities. By delving into subdomain enumeration, mobile apps, fuzzing, web caching, Bluetooth, GraphQL, and firmware and hardware hacking, you can discover obscure but high-value bugs that set you apart from the competition. Remember that while these techniques might be less popular, they can lead to significant payouts and recognition in the bug hunting community. However, always act responsibly, adhere to the bug bounty program's rules, and obtain proper authorization before probing any system or application. Happy bug hunting!

Machine Learning Model Deployment with FastAPI and Docker

Code_Jedi — Sun, 24 Sep 2023 08:32:28 +0000

Machine learning model deployment is a crucial step in making your ML models accessible to users and applications. FastAPI, a modern Python web framework, and Docker, a containerization platform, have gained popularity for their efficiency and simplicity in deploying machine learning models. In this tutorial, we'll walk through the process of deploying a machine learning model using FastAPI and Docker, making it accessible via a RESTful API.

Before we get into this article, if you want to learn more on Machine Learning and Docker, I would recommend the tutorials over at Educative, who I chose to partner with for this tutorial.

Prerequisites

Before we begin, ensure you have the following:

Python and pip installed on your system.
Basic understanding of machine learning and Python.
Docker installed on your system. You can download it from the official website: https://www.docker.com/get-started.

Create a Machine Learning Model

For this tutorial, we'll use a simple scikit-learn model to classify iris flowers. You can replace it with your own trained model.

Create a Python script (e.g., model.py) and define your model:

   import joblib
   from sklearn.datasets import load_iris
   from sklearn.ensemble import RandomForestClassifier

   # Load the iris dataset
   iris = load_iris()
   X, y = iris.data, iris.target

   # Train a random forest classifier
   model = RandomForestClassifier()
   model.fit(X, y)

   # Save the trained model
   joblib.dump(model, 'model.joblib')

Run the script to train and save your model:

   python model.py

Create a FastAPI App

Now, let's create a FastAPI app that serves the machine learning model as a RESTful API.

Create a new directory for your FastAPI app:

   mkdir fastapi-docker-ml
   cd fastapi-docker-ml

Install FastAPI and Uvicorn:

   pip install fastapi uvicorn

Create a FastAPI app script (e.g., app.py) and define the API:

   from fastapi import FastAPI
   import joblib
   import numpy as np

   app = FastAPI()

   # Load the trained model
   model = joblib.load('model.joblib')

   @app.get("/")
   def read_root():
       return {"message": "Welcome to the ML Model API"}

   @app.post("/predict/")
   def predict(data: dict):
       features = np.array(data['features']).reshape(1, -1)
       prediction = model.predict(features)
       class_name = iris.target_names[prediction][0]
       return {"class": class_name}

Create a Dockerfile

To containerize our FastAPI app, we'll create a Dockerfile.

Create a file named Dockerfile (without any file extensions) in the same directory as your FastAPI app:

   # Use the official Python image
   FROM python:3.9

   # Set the working directory in the container
   WORKDIR /app

   # Copy the local code to the container
   COPY . .

   # Install FastAPI and Uvicorn
   RUN pip install fastapi uvicorn

   # Expose the port the app runs on
   EXPOSE 8000

   # Command to run the application
   CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

Build and Run the Docker Container

With the Dockerfile in place, you can now build and run the Docker container.

Build the Docker image:

   docker build -t fastapi-docker-ml .

Run the Docker container:

   docker run -d -p 8000:8000 fastapi-docker-ml

Test the API

Your FastAPI app is now running in a Docker container. You can test it by making POST requests to the /predict/ endpoint:

curl -X POST "http://localhost:8000/predict/" -H "accept: application/json" -H "Content-Type: application/json" -d '{"features": [5.1, 3.5, 1.4, 0.2]}'

This will return the predicted class for the given input features.

Conclusion

You've successfully deployed a machine learning model using FastAPI and Docker, creating a RESTful API that can be accessed from anywhere. This approach allows you to easily scale your ML model deployment and integrate it into various applications and services. Explore further by enhancing your FastAPI app, adding authentication, and optimizing your Docker container for production use.

Building a Sentiment Analysis App with Python and Hugging Face Transformers

Code_Jedi — Sun, 24 Sep 2023 07:51:42 +0000

Sentiment analysis, also known as opinion mining, is a natural language processing (NLP) task that involves determining the sentiment or emotional tone expressed in a piece of text. With the help of Hugging Face Transformers, a popular library for NLP, we can easily create a sentiment analysis app that can classify text as positive, negative, or neutral. In this tutorial, we'll walk through the steps to build a sentiment analysis app using Python and Hugging Face Transformers.

Before we get into this article, if you want to learn more on NLP and Hugging face, I would recommend the tutorials over at Educative, who I chose to partner with for this tutorial.

Prerequisites

Before we begin, make sure you have the following prerequisites:

Python 3 installed on your system.
Basic knowledge of Python programming.
An understanding of natural language processing (NLP) concepts.

Step 1: Installing the Required Libraries

First, we need to install the necessary Python libraries, including Hugging Face Transformers and Flask, a web framework for building web applications.

pip install transformers
pip install flask

Step 2: Creating a Sentiment Analysis Flask App

Now, let's create a Flask app that performs sentiment analysis using a pre-trained model from Hugging Face Transformers.

# app.py

import torch
from transformers import pipeline
from flask import Flask, request, jsonify

app = Flask(__name__)

# Load the sentiment analysis model
sentiment_analysis = pipeline("sentiment-analysis")

@app.route("/analyze", methods=["POST"])
def analyze_sentiment():
    try:
        data = request.json
        text = data["text"]

        # Perform sentiment analysis
        result = sentiment_analysis(text)

        return jsonify({"sentiment": result[0]["label"], "score": result[0]["score"]})

    except Exception as e:
        return jsonify({"error": str(e)}), 500

if __name__ == "__main__":
    app.run(debug=True)

In this code, we create a Flask app with a single route /analyze that accepts a JSON payload with a "text" field and returns the sentiment analysis result as JSON.

Step 3: Running the Flask App

Now, let's run our Flask app:

python app.py

Your Flask app should start running on http://127.0.0.1:5000/.

Step 4: Testing the Sentiment Analysis API

You can test the sentiment analysis API using a tool like curl or by creating a simple client application. Here's an example using Python's requests library:

# client.py

import requests

url = "http://127.0.0.1:5000/analyze"

data = {"text": "I love this product! It's amazing!"}
response = requests.post(url, json=data)

if response.status_code == 200:
    result = response.json()
    print(f"Sentiment: {result['sentiment']}")
    print(f"Sentiment Score: {result['score']}")
else:
    print(f"Error: {response.text}")

Run the client script:

python client.py

You should see the sentiment analysis result for the provided text.

Conclusion

Congratulations! You've built a simple sentiment analysis app using Hugging Face Transformers and Flask. This app can classify text as positive, negative, or neutral. You can extend this project by improving the user interface, integrating it with a front-end framework, or deploying it to a web server to make it accessible from anywhere. Sentiment analysis has numerous applications, including social media monitoring, customer feedback analysis, and more.

Getting Started with Flutter: Building a Cross-Platform Mobile App

Code_Jedi — Sat, 23 Sep 2023 16:19:42 +0000

Flutter, developed by Google, is a popular open-source UI framework for building natively compiled applications for mobile, web, and desktop from a single codebase. It enables developers to create beautiful and high-performance apps for iOS, Android, and the web with a single codebase. In this tutorial, we'll walk through the process of getting started with Flutter and building a simple cross-platform mobile app.

Before we get into this article, if you want to learn more on Flutter, I would recommend the tutorials over at Educative, who I chose to partner with for this tutorial.

Prerequisites

Before we begin, ensure that you have the following tools and knowledge:

Flutter SDK installed on your system. You can download it from the official website: https://flutter.dev/docs/get-started/install.
An integrated development environment (IDE) like Visual Studio Code (recommended) or Android Studio with the Flutter plugin installed.
Basic knowledge of Dart, the programming language used by Flutter.

Step 1: Setting Up Flutter

Let's start by setting up Flutter on your system:

Install Flutter by following the official installation guide: https://flutter.dev/docs/get-started/install.
Verify your installation by running the following command:

   flutter doctor

This command will check for any issues with your Flutter installation and provide recommendations to resolve them.

Step 2: Creating a New Flutter Project

Now that Flutter is set up, let's create a new Flutter project:

Open your terminal and run the following command to create a new Flutter app:

   flutter create my_first_flutter_app

Replace my_first_flutter_app with your preferred project name.

Navigate to the project directory:

   cd my_first_flutter_app

Step 3: Building the App

Let's build a simple counter app to get started:

Open the lib/main.dart file in your project directory. This is the entry point for your Flutter app.
Replace the existing code with the following:

   import 'package:flutter/material.dart';

   void main() {
     runApp(MyApp());
   }

   class MyApp extends StatefulWidget {
     @override
     _MyAppState createState() => _MyAppState();
   }

   class _MyAppState extends State<MyApp> {
     int _counter = 0;

     void _incrementCounter() {
       setState(() {
         _counter++;
       });
     }

     @override
     Widget build(BuildContext context) {
       return MaterialApp(
         home: Scaffold(
           appBar: AppBar(
             title: Text('Flutter Counter App'),
           ),
           body: Center(
             child: Column(
               mainAxisAlignment: MainAxisAlignment.center,
               children: <Widget>[
                 Text(
                   'Counter:',
                   style: TextStyle(fontSize: 24),
                 ),
                 Text(
                   '$_counter',
                   style: TextStyle(fontSize: 48, fontWeight: FontWeight.bold),
                 ),
                 SizedBox(height: 20),
                 ElevatedButton(
                   onPressed: _incrementCounter,
                   child: Text('Increment Counter'),
                 ),
               ],
             ),
           ),
         ),
       );
     }
   }

This code defines a simple Flutter app with a counter that increments when a button is pressed.

Step 4: Running the App

You can run your Flutter app on an emulator or a physical device:

Ensure you have an emulator or a physical device connected and recognized by Flutter.
Run the following command to start the app:

   flutter run

This command will build and run the app on the selected device.

Conclusion

Congratulations! You've successfully created a basic Flutter app. Flutter's extensive widget library and cross-platform capabilities make it a powerful choice for developing mobile applications. You can expand on this tutorial by exploring more Flutter widgets, adding navigation, integrating APIs, and building more complex and feature-rich apps. Happy coding!

Text Classification with Natural Language Processing (NLP) in Python using Scikit-Learn

Code_Jedi — Thu, 21 Sep 2023 18:01:22 +0000

Text classification is a fundamental task in natural language processing (NLP) that involves assigning predefined categories or labels to textual data. This technique has a wide range of applications, from sentiment analysis and spam detection to topic categorization. In this article, we'll explore how to perform text classification using Python and the Scikit-Learn library. We'll walk through the process step by step, including data preprocessing, feature extraction, model training, and evaluation.

Before we get into this article, if you really want to learn NLP and other new technologies, I would recommend tutorials and courses over at Educative, who I am affiliated with.

Prerequisites

Before we get started, make sure you have Python and Scikit-Learn installed on your system. You can install Scikit-Learn using pip:

pip install scikit-learn

Dataset

For this example, we'll use the "20 Newsgroups" dataset, a collection of newsgroup documents organized into 20 different categories. We'll perform binary text classification to distinguish between two categories: "sci.space" and "comp.graphics."

Step 1: Data Preprocessing

Let's begin by loading and preprocessing the dataset. We'll use Scikit-Learn's built-in function to fetch the data and perform some basic text cleaning.

from sklearn.datasets import fetch_20newsgroups

# Define the categories we want to classify
categories = ['sci.space', 'comp.graphics']

# Fetch the training dataset
newsgroups_train = fetch_20newsgroups(subset='train', categories=categories, remove=('headers', 'footers', 'quotes'))

# Fetch the testing dataset
newsgroups_test = fetch_20newsgroups(subset='test', categories=categories, remove=('headers', 'footers', 'quotes'))

Step 2: Feature Extraction

To perform text classification, we need to convert the text data into numerical features that machine learning models can understand. We'll use the TF-IDF (Term Frequency-Inverse Document Frequency) vectorizer to do this.

from sklearn.feature_extraction.text import TfidfVectorizer

# Create a TF-IDF vectorizer
tfidf_vectorizer = TfidfVectorizer(max_features=1000)

# Fit and transform the training data
X_train_tfidf = tfidf_vectorizer.fit_transform(newsgroups_train.data)

# Transform the testing data
X_test_tfidf = tfidf_vectorizer.transform(newsgroups_test.data)

Step 3: Model Training

Now, let's train a text classification model. We'll use a simple logistic regression classifier for this example.

from sklearn.linear_model import LogisticRegression

# Create a logistic regression classifier
clf = LogisticRegression()

# Train the model
clf.fit(X_train_tfidf, newsgroups_train.target)

Step 4: Model Evaluation

Finally, let's evaluate the performance of our text classification model on the test data.

from sklearn.metrics import accuracy_score, classification_report

# Make predictions on the test data
predicted = clf.predict(X_test_tfidf)

# Calculate accuracy
accuracy = accuracy_score(newsgroups_test.target, predicted)
print(f"Accuracy: {accuracy:.2f}")

# Display classification report
report = classification_report(newsgroups_test.target, predicted, target_names=newsgroups_test.target_names)
print("Classification Report:\n", report)

Conclusion

Text classification is a foundational NLP task with numerous practical applications. By mastering these techniques and exploring more advanced models and datasets, you can leverage the power of NLP for tasks such as sentiment analysis, document categorization, and more. Experiment with different algorithms and feature extraction methods to further improve the accuracy of your text classification models.

How to Edit Images in Bulk With Python( In < 20 Lines of Code )

Code_Jedi — Tue, 28 Jun 2022 09:48:31 +0000

Whether it's adding captions, resizing or enhancing, I will demonstrate how you can edit images in bulk using Python in under 20 lines of code.

First, install Pillow:

pip3 install Pillow

Create a new Python file and place it where it can access your image folder. You can do this by either moving the image folder into your Python file's directory or moving the Python file into your image folder's parent directory.

You will also have to create a new folder next to your image folder for saving the edited images. I will call the folder "edited" but you can call it whatever you want.

Open your Python file and make the following imports:

from PIL import Image
from PIL import ImageFont
from PIL import ImageDraw 
import os

Once that's done, add the following to your Python file.

for g in range(len(os.listdir("photos"))):

Using this for loop, you'll be able to automatically edit every image in your folder.

Now, add the following code into your for loop in order to load the images.

imgstr = str(os.listdir("photos")[g])
img = Image.open("photos/"+imgstr)

Then add the following code to enhance your images.

converter = ImageEnhance.Color(img)
img2 = converter.enhance(0.1)

This will give your images the black/white effect. This is just an example. You can edit your images in other ways such as adding captions or changing size.
You can refer to the official documentation for more methods.

Finally, you should add the following into your for loop to save the edited versions of your images into your "edited" folder.

img2 = converter.enhance(0.1)
img2.save("edited/"+str(imgstr[:imgstr.index(".")]+str(".png")))

You probably noticed that I made the img2.save() function save the edited images in the .png format. This is because color enhancements are only compatible with .gif and .png images. As far as I'm aware, you only need to convert the images into .png or .gif when you're enhancing its color, but if you see the following error when editing your images in other ways, just know that you need to convert them either into .png or .gif.

OSError: cannot write mode RGBA as JPEG

Original

Edited

Full Code

from PIL import Image,ImageEnhance
from PIL import ImageFont
from PIL import ImageDraw 
import os

for g in range(len(os.listdir("photos"))):
    imgstr = str(os.listdir("photos")[g])
    img = Image.open("photos/"+imgstr)
    converter = ImageEnhance.Color(img)
    img2 = converter.enhance(0.1)
    img2.save("edited/"+str(imgstr[:imgstr.index(".")]+str(".png")))

Speed Up Your Javascript With These Simple Methods

Code_Jedi — Wed, 15 Jun 2022 12:45:23 +0000

If your Javascript code is running slower than you'd like, or if you just want to know how to make your code faster regardless, stick around for some easy to implement ways of making your Javascript run faster

Bottom of Webpage

To make your webpage's loading faster, make sure your Javascript code is at the bottom of your HTML webpage's body tag.

Web Workers

If your webpage uses time-intensive Javascript operations, web workers can save you a lot of time. Using web workers can mean the difference between an unresponsive and slow webpage, and a smooth running and fast webpage.

Web workers are separate threads created by your main Javascript code to work in parallel with the main process.
You can read about web workers and their JS implementation here

Saving DOM Elements

When manipulating the same DOM element multiple times, to speed up your code, you should define it once and then keep referencing it.
No

const el1 = document.getElementById("demo");
el1.style.color = "green";

const el1 = document.getElementById("demo");
el1.style.color = "blue";

const el1 = document.getElementById("demo");
el1.style.color = "pink";

Yes

const el1 = document.getElementById("demo");
el1.style.color = "green";

el1.style.color = "blue";

el1.style.color = "pink";

Reduce Library Dependancies

Loading libraries in JS can take up a lot of time, make sure to remove any unneeded library dependancies in your Javascript code.

Reduce Loop Activity

In Javascript, loops can take quite a lot of time to finish running. A simple way to make your JS loops run faster is by defining the loop parameters before the loop itself.
No

for (let g = 0; g < arr.length; g++) {

Yes

let arrlen = arr.length;
for (let g = 0; g < arrlen; g++) {

This will speed up your for loop because now, instead of getting the length of the "arr" array every single iteration, it will get that value once and reuse it throughout every iteration.

Avoid Global Variables

Global variables can slow down your JS code. When defining a variable for the first time, make sure to add the var prefix to make it a local variable instead of a global one.
No

v1 = 9

Yes

var v1 = 9

Conclusion

I hope that these were helpful.

How to Convert Unix Time to Datetime and Vice Versa in Python

Code_Jedi — Mon, 30 May 2022 10:50:38 +0000

Unix timestamps are unreadable to humans, Datetimes are unreadable to machines. Time often needs to converted between Unix and Datetime. I'll demonstrate how you can do that in Python.

Unix to Datetime

import time
from datetime import datetime
#convert unix to datetime
print(datetime.utcfromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S'))

Datetime to Unix

import time
from datetime import datetime
#convert unix to datetime
dtm = datetime.utcfromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')

#convert datetime back to unix
dtt = datetime.strptime(dtm, '%Y-%m-%d %H:%M:%S')
print(datetime.timestamp(dtt))

⚡️20 Easy Ways to Be More Productive as a Developer⚡️

Code_Jedi — Mon, 18 Apr 2022 08:07:20 +0000

Everyone wants to be more productive, but how do you become more productive? Well, hopefully you'll find some answers in this article where I've compiled 20 easy, tried and tested methods for becoming more productive as a developer!

1. Time boxing

Divide your time into boxes like:

9:30 --> 10:00
Emails

10:00 --> 12:00
Plan new landing page design and functionality

12:00 --> 13:00
Lunch and break

13:00 --> 15:00
Editing Documentation

15:00 --> 17:30
Work on redesigning landing page

2. Deep work

Deep work is a productivity method that's all about getting into the zone. The idea is that you try working non-stop for long periods of time(2 to 3 hours) so that you get into a sort of flow. Then, when you're in that flow, it's going to be hard to break out and start procrastinating again.

3. The 80/20 Rule

Also called the Pareto Principle, the 80/20 Rule encourages you to do more of your highest value work. It suggests that 80% of your output tends to come from only 20% of your efforts. This method is about identifying which of your tasks provide the biggest return and prioritizing them. It is about spending your energy on the “right work” instead of wasting time on the minor details.

4. The Rule of Three

The Rule of Three is a great technique for people who are overly ambitious, or write to-do lists that they rarely ever complete. It’s about prioritizing what’s most important and focusing on having a meaningful outcome for your day. This technique simply entails writing down three things you want to achieve each day. Crucially, they shouldn’t be tasks – they should be results, like “Application deployed to AWS”. By kicking off your day with three meaningful intentions, you’re continually reminding yourself of what’s important and what you should be focusing on. This seemingly small action can have a big outcome.

5. Do Something

We've all been in a rut (really unproductive time-period) where we don't seem to have any motivation or energy, and we just generally feel unable to get any work done. When this happens, the best thing to do is to do something. Do some chores around the house/apartment, write some code(doesn't have to relevant to your job/projects), write a blog post. Just doing something productive is often the best way to get out of a rut and getting back on track!

6. Eat the Frog

Think of that thing that you've been procrastinating on for a long time. This can be a hard project, or learning something that's intimidating. Now, start on it with no hesitation. Just start. You might be afraid of making mistakes or not quite getting it the first time, but once you start, you'll gradually become more and more comfortable with that task!

7. Don’t Repeat Yourself

The Don’t Repeat Yourself method (or DRY Principle) is about saving time by reusing and recycling work you’ve already done. Repetition is by its nature inefficient and needless, so the DRY Principle encourages you to create workflows and templates to minimize it. You can apply this principle to code, emails, blog posts and much more!

7. Don’t Repeat Yourself

Just kidding ;)

8. The two-minute rule

The two-minute rule suggests that if you have any tasks on your to-do list that will take two minutes or less to complete, you should just do them now. The purpose of this method is to overcome procrastination by taking immediate action – so if you have an email to respond to and it’s weighing on your mind, reply to it now if it will only take two minutes to do so. This will make you feel you’ve accomplished something, which in turn boosts your motivation and builds momentum. Plus, it helps clear your mind and stops you from worrying about all those tiny tasks you still have to do.

9. Single-tasking

Multi-tasking can be a killer of productivity. Single-tasking is a method that encourages you to focus on one thing at a time. This way, you will spend less time and energy on going back and forth between tasks.

10. Must, Should, Want

Before starting your day, create a list based on these criteria:

I must ...
I need to ...
I want to ...

This will help you prioritize your tasks and set your intention for the day.

11. The Eisenhower Matrix

I know this sounds very fancy but this method is just about making a list of all of the tasks you need to do, then put them into four different categories.

These four categories are:

Urgent and important tasks
Important but not urgent tasks
Urgent but not important tasks
Not urgent or important tasks

This will help you prioritize your time for different tasks based on where they are within the categories.

12. Biological Prime Time

Start by discovering your natural energy levels throughout the day.

To do so, take a few weeks to document how energetic you're feeling throughout the day.

For each hour of the day – give it a grade between 1-10 (10 being high energy). Based on what you’ve discovered – plan your day accordingly. If you naturally have high energy levels in the morning – do the tasks you’ll need the most focus and energy for in the morning.
If you have low energy levels in the afternoon – save your low energy tasks for that time. These tasks can be going through emails or writing a blog post for dev.to.

13. The Weekly Review

Once a week, you’ll want to sit down in a quiet place where you can think and reflect. You could also use a notebook and pen if you wanted to keep physical track of the information.

You’ll want to review your past week in terms of productivity, energy levels, what worked for you, and what didn’t

For example:

Having a cold shower in the morning made a great productivity change for me.
Eating too little in the morning made me feel low for the next couple of hours.

In addition to thinking about how the week went, you’ll want to look at what decisions you made and which ones you wanted to change. You can come up with ideas to improve your results and you can catch up with anything you didn’t get done.

14. Pomodoro

This is probably the most famous productivity method out there. The Pomodoro method works like this:

You work for 20-30 minutes
You rest for 5-10 minutes
Repeat

This method encourages the opposite of the deep work method, so if you know that the deep work method works for you, don't bother with this one, and vice versa.

15. The Not-to-do list

Lots of productivity methods encourage you to make some sort of to-do list. But not-to-do lists are often overlooked, yet can be very useful for productivity!
At the beginning of your day, make a not-to-do list. This list will contain unproductive things that you want to avoid doing like using Reddit or Twitter, chatting with friends during your working hours or listening to podcasts that distract you.

This way, you will have a clear idea of the unproductive things you want to avoid doing during your day.

16. Organize Tomorrow Today

Organize and plan tomorrow's tasks before you go to sleep. This way, you'd be able to start on those tasks the next day without hesitation or planning.

17. The Checklist Manifesto

For everything you do more than once, or simply a complex task you want to complete – start by creating a detailed checklist of what you need to do to complete it the right way.
For example:

Writing a blog post
* Write the outline
* Write the rough content
* Review and edit
* Read through it
* Final review and edit
* Publish

18. Don’t Break the Chain

This method revolves around you completing a daily task over an extended period of time. For each day you’ve completed your task – you simply go to your calendar and mark that day as done. This task can be something like writing a blog post, learning something new or reading a book for 30 minutes.

The first few days of commitment are usually the hardest – but your motivation to make a change pulls you through.

As the chain grows longer, not breaking your streak becomes a renewal of its own and motivates you to keep going.

19. The SMART goals method

SMART is a goal-setting formula that encourages you to be as detailed and concrete about what it is you are trying to achieve. SMART stands for Specific, Measurable, Assignable, Realistic, Time-related. This means that when you set a goal it should be well defined in a clear way.

It should include: What it is you are trying to achieve, how you will measure success, who’s in-charge, grounded, and doable, and what’s the time frame in which it needs to be achieved.

20. The Recharge method

When you feel that you're tired and can't work anymore, instead of trying to push yourself, acknowledge that you need a break and take it. It's often better to take breaks when you are mentally drained than to push yourself for 3 reasons:

You will make less mistakes
You will be less stressed
You will have more mental clarity

Conclusion

I hope you found some productivity methods that you think will help you!

Oh and also, I learned a lot of these methods from the following articles so it would be weird if I didn't reference them:

This one from any.do
This one from memory.ai

Be sure to check out their articles if you enjoyed this one.

How to Find Your WiFi Password and Share It With Others Through a QR Code in Bash!

Code_Jedi — Thu, 14 Apr 2022 13:50:37 +0000

Did you ever forget your WiFi password? Or did you ever have guests over and needed an easy way to share your WiFi?
Well in this mini-tutorial, I'll show how you can easily find your WiFi password and share it with others through a QR code using a command-line tool.

Installing the Tool

The tool that is going to allow you to do this needs to be installed through NPM so make sure you have NPM installed. You can use this guide for installing NPM.

Once you have NPM installed, install the wifi-password-cli module using:

npm install --global wifi-password-cli

Using the Tool

Now that you have the module installed, use the following to see its usage:

wifi-password --help

You will see the following output:

usage: wifi-password [options]

optional arguments:
  -h, --help            show this help message and exit
  --show-qr, -show      Show a ASCII QR code onto the terminal/console
  --save-qr [PATH], -save [PATH]
                        Create the QR code and save it as an image
  --ssid SSID, -s SSID  Specify a SSID that you have previously connected to
  --version             Show version number

You can simply display your WiFi password through the terminal using:

wifi-password

This will prompt you with a security sudo user confirmation window:

I have a macOS, but you will see a different prompt depending on your OS. Enter the required information and your WiFi password will be displayed in terminal!

You can use the following command to generate and display a QR code of your WiFi password for guests to scan:

wifi-password --show-qr

You can save this QR code as an image using the following command:

wifi-password --save-qr [PATH]

You can choose where to save the image by varying the path argument at the end, for example:

wifi-password --save-qr /usr/local/images

Conclusion

I hope this will come in helpful ;)

Don't Memorize What You Can Google!

Code_Jedi — Sat, 09 Apr 2022 13:51:09 +0000

This is something that might seem weird for beginners, yet is something that every beginner should know if they want to save their time and frustration.

What do I mean by "Don't Memorize What You Can Google"?
Simply: Memorize core concepts and functions that are essential for working with your programming language or framework, but don't memorize random functions, code snippets and concepts that you will rarely use! Instead, take advantage of external resources(forums, blogs, notes, books, documentations...) for those things when they are needed.

Don't memorize things that take 1 minute to find through google like:

Why This is Important for Beginners

I've seen beginner programmers memorize random things about a language or framework because they thought that memorizing more will make them more competent since they will be faster since they'd be able to code without using google often.

Yes you will code a bit faster, but this approach will backfire sooner or later. See, this approach might make you faster for a bit of time, but it will bring 3 major downsides in the long run:

The first downside is brain cluttering. Trying to clutter your brain with random info that is rarely used is as dumb as it sounds. Instead, you should memorize core concepts, functions and code snippets that you use often.
The second downside is a steeper learning curve. If the way you learn a new language or framework is by memorizing a ton of different, mostly irrelevant things, you will have a hard time every time you try to learn something new.
The last downside is frustration. You will likely get frustrated if you can't remember something and when this happens too much, you can turn your programming life into a living hell.

Instead, you should memorize only what is essential for working with your language or framework. For example, if you're working with PHP, you should memorize how to use "GET" and "POST". Or, if you're working with data science in Python, you should memorize how to load a dataset through pandas. You get the idea. Don't worry about the non-essentials.

In Conclusion

Your brain's "storage" is precious and limited. Don't fill it with random code snippets, functions and concepts.

See you next time👋

15 Creative Web Dev Project Ideas for Your Portfolio (That You Can Finish in a Weekend)

Code_Jedi — Wed, 06 Apr 2022 14:15:16 +0000

Are you tired of blogs telling you to make a to-do app, weather app or personal blog? They're great beginner Web Dev projects, but they've been made a million times.
In this article, I will compile 15 creative, Web Dev project ideas that you can finish in 1 or 2 weekends, and that haven't been made and talked about on literally every Web Dev blog already. Now of course, some of these projects will require a bit of backend 'cause you can't go very far in terms of Web Dev without using a bit of backend.

1. An r/place Inspired Platform

This is one that I want to make in the near future myself. Basically, for those of you unfamiliar with r/place, it was basically a sort of game on reddit where users would have a shared canvas and they would try to draw things on the canvas. What made the game challenging is that, since it was played by 10,000s of players at any given time, it was hard to take a chunk of the canvas and draw something significant without it getting destroyed like some people's vain attempt at drawing and maintaining the Canadien flag.

You can make a Web App that works similar to r/place that will give users the ability to place tiles on a large canvas, as well as limiting their power over the canvas by allowing them to place a tile once every, say, 5 or 10 mins. r/place is very general and has no particular theme. I mean, users could draw flags but most users chose to draw random shit lmao😂.
Unlike r/place, you can make your game themed around programming, music, movies, video games and just about anything else!

Skillset demonstrated:

UI/UX
Handling user generated content

2. A Smart Music Player

What if you tried making a music player that doesn't just let you play tracks, but also makes personalized mixes like Spotify? In addition to this you can make it have unique features like for example, making a "bangers" mix that compiles the tracks that you've cranked up your volume for.

Skillset demonstrated:

UI/UX
User data analysis
Audio event handling(pause, rewind, skip, e.t.c)

3. A Tweet Agregator

This is one that I've made as a weekend project myself. The idea is that you make a Web App that curates tweets and displays them on a daily basis using the twitter API. You can make one that, say, curates the latest programming tweets from big accounts in the niche.

Skillset demonstrated:

Working with APIs
Organizing and displaying data fetched from the API

4. A Live Data Visualization Web App

This is one of the easier projects on this list, yet one that is very versatile. You can make a Web App that visualizes live data fetched from an API. This can be, for example, a financial data API where you would visualize the most traded stocks by volume.

Skillset demonstrated:

Working with APIs
Organizing and displaying data fetched from API
Visualizing data on a web page

5. A Multi-Functional Unit Converter

There's a lot of units out there. Temperature, Energy, Distance... you name it. A simple yet useful Web Dev project would be a multi-functional unit converter that would be able to convert units from any category like temperature or energy.

Skillset demonstrated:

Processing user input
Converting user input through functions and mathematical operations
Conditional element rendering

6. A Platformer Game

While the ability to make games is not something most recruiters look for in a Web Dev. It's fun, and it's nevertheless a good demonstration of what you can do with some HTML and Javascript. here is a good example of a web based platformer game. And here's another.

Skillset demonstrated:

Detecting user interactions
Manipulating web elements
Game development

7. A User Generated Blog

Blogs are much appreciated across the internet. Blogs can be very valuable for businesses. Personal blogs have been made like a million times by Web Devs already, but user-generated blogs like dev.to that have a built-in markdown editor, review algorithm and everything else needed to have a self-sustaining blog is something not many have made, yet is something that is a lot more valuable to businesses that want their blog to grow organically and bring in traffic. This project can be a fine addition to your Web Dev portfolio.

Skillset demonstrated:

Handling user generated content
Creating blog recommendation and review algorithms

8. A Web Store Landing Page

Upload some designs to redbubble, it takes like 10 mins to setup and like an hour to upload some designs(they don't have to be great). Then, a great Web Dev project idea would be to make your own landing page for your products. Web Devs that can make great product landing pages are more valuable than ever. If you can show that you can make a unique, good looking product/online store landing page, your portfolio won't need much more.

Skillset demonstrated:

UI/UX
Creating landing pages

9. A Newsletter Landing Page

Just like with product landing pages, knowing how to make great newsletter landing pages is a valuable Web Dev skill. So if you're trying to grow your newsletter, taking the time to make a great landing page for it will be worthwhile for your portfolio.

Skillset demonstrated:

UI/UX
Creating landing pages

10. An Image Editing Web App

I often use online image editing Web Apps such as vectr to make things like cover images. You can make a similar Web App that has a simple UI yet versatile functionality.

Skillset demonstrated:

Processing user file uploads
Editing image properties
Adding/Removing effects and elements

11. A Documentation for Your Library or API

If you've ever made something like a library or API, take the time to make a comprehensive, good looking documentation for it. When working with companies that make their own APIs or libraries, knowing how to make a great documentation will make you stand out.

Skillset demonstrated:

UI/UX
Building a well-put together documentation

12. A Browser Extension SaaS

Browser extensions are pretty cool and can be used for a variety of things to make your browsing experience better. Many SaaS businesses are implementing their services in a browser extension. You can make your own browser-extension-as-a-Service. Maybe one that solves a problem you've faced while browsing or just a fun add-on for procrastinators ;)

Skillset demonstrated:

Browser Extension development
Knowing your way around the DOM
SaaS development

13. Your Own NFT Web Store

I'm not a big fan of NFTs, but the truth is, hate it or love it, businesses from a variety of different industries are expanding into the NFT space. You can make your own NFT web store where you will implement web3 and crypto transaction frameworks. This project is a sure-fire way to get recognized for your web3 development skills and can be a great addition to your portfolio.

Skillset demonstrated:

Web3 development
Web3 authentication
Crypto transaction management
Encryption/Decryption

14. A CSS or JS Library

You don't always have to make your own Web App or website to put on your portfolio. You can just make some useful CSS or JS libraries meant to be integrated with others code.

Skillset demonstrated:

Writing integratabtle CSS or JS code
Web Design and/or Javascript Development

15. An Image Gallery

This is a project that won't involve much functionality, but is one that can be fun and will show case your web design skills. You can make an image gallery about your favorite cars, plants, west-coast rappers... you name it. Here's a great example, but be sure to be original with your design.

Skillset demonstrated:

UI/UX
Web Design

Conclusion

I hope that you found some of these ideas innovative and worthwhile! If this article does well, I'll post a part 2.