DEV Community: Tony Hunter

Keeping Your Passwords Safe: The Bcrypt Way

Tony Hunter — Sun, 08 Oct 2023 07:31:23 +0000

In the world of online security, protecting your passwords is like locking the door to your digital house. One powerful way to do this is by using something called bcrypt, which is like a super-smart lock for your passwords. Let's explore how this works, without getting too technical.

How Bcrypt Keeps Your Passwords Safe

Imagine you have a secret password, like your own personal key to your digital life. Bcrypt takes that password and does some clever math to turn it into a secret code. This code is unique to your password, like your very own secret language that only your computer understands.

Now, here's where bcrypt gets even smarter. It adds a little extra something called a "salt" to your password before turning it into a secret code. Think of the salt as a unique ingredient that makes your password even more secure. Every password gets its own special salt, so even if two people have the same password, their secret codes will look completely different.

How Bcrypt Helps Your Password Stay Safe

When you create a new account or set a password, bcrypt does its magic and creates this secret code. It keeps this secret code safe in the computer, and it doesn't even know what your original password is – it's like turning your password into a secret recipe that only your computer chef knows.

Later, when you come back and type in your password to log in, bcrypt checks if the secret code it made matches the one it stored. It doesn't need to know your actual password – it just knows if the secret code matches. This is like your computer bouncer checking if you have the right secret handshake to let you into your digital party.

Making It Simple in Python

Here's a quick look at how Python, a computer language, uses bcrypt:

First, using the terminal window, we must import the Bcrypt library to python using:

Pipenv install flask-bcrypt

Then in your config.py file instantiate an instance of Bcrypt on your app:

from flask_bcrypt import Bcrypt

# Wrapping your app using the Bcrypt method
bcrypt = Bcrypt(app)

Then inside of your app.py file, or the file that holds your User model, you could implement the methods from Bcrypt like:

#additional import from the SQLalchemy library for handling the password variable indirectly
from sqlalchemy.ext.hybrid import hybrid_property

# Creating a secret code for your password
class User(db.Model)
  __tablename__ = "users"

    id = db.Column(db.Integer, primary_key=True)
    _password_hash = db.Column(db.String)

    @hybrid_property
    def password_hash(self):
        # this prevents the password from being accessed directly from the database
        raise Exception("Cannot access password hashes")

    @password_hash.setter
    def password_hash(self, password):
        hashed_pw = bcrypt.generate_password_hash(password).decode("utf8")
        #this sets the password property indirectly to prevent it being changed by direct methods from outside sources
        self._password_hash = hashed_pw

hashed_password = bcrypt.hashpw("your_password".encode('utf-8'), bcrypt.gensalt())

# Checking if your entered password matches the secret code
is_password_correct = bcrypt.checkpw("your_entered_password".encode('utf-8'), hashed_password)

In simpler terms, bcrypt helps create a secret code for your password that’s unique and hard for bad guys to crack. It adds a sprinkle of extra security with a salt, making your password extra safe. It’s like having a guardian for your digital key, ensuring only you can unlock the door to your online world. Stay safe and secure those passwords!

Navigating Databases with Python: A Beginner-Friendly Guide

Tony Hunter — Fri, 18 Aug 2023 21:28:12 +0000

Hey there, fellow non-techies! Have you ever wondered how those magical databases work behind the scenes? Fear not, for I'm here to demystify the world of databases and show you how Python can be your trusty sidekick in this journey. In this blog, I'll walk you through the basics of using databases with Python, share some easy-to-follow best practices for creating your own, and even dive into the intriguing world of table joins. Let's get started!

What's a Database Anyway?

Think of a database as a digital treasure chest where you can store and organize all kinds of information. Imagine you have a virtual notebook with different sections to jot down notes, and you can quickly flip to the right page whenever you need. That's what a database does, but in a super efficient and organized way!

Python: Your Friendly Database Companion

You might be thinking, "Databases sound cool, but aren't they super complicated?" Well, that's where Python comes to the rescue. Python is like a friendly guide that helps you navigate through the database world without breaking a sweat. Here's a simple roadmap to follow:

Pick Your Database System: Just like you choose between different notebook designs, you can choose a database system. Some popular ones are SQLite, MySQL, and PostgreSQL. Each has its own strengths and quirks.
Get the Right Tools: Think of Python libraries as special tools you need to open your virtual notebook. For example, if you're using SQLite, you'll want to import the sqlite3 library.

import sqlite3

Open the Database Door: You don't need a secret key to access a database, just a connection. It's like opening the treasure chest – you use Python to knock on the database's door.

import sqlite3

# Connect to SQLite database
conn = sqlite3.connect('my_database.db')

Start Exploring with a Cursor: Imagine a cursor as a magic wand that lets you point to different parts of the database. You can use it to create tables, add data, and more.

# Create a cursor
cursor = conn.cursor()

Speak Database Language: Now comes the exciting part! You use a special language called SQL (Structured Query Language) to talk to the database. It's like writing a note to tell the database what you want.

# Let's create a table to store favorite books
cursor.execute('''
    CREATE TABLE IF NOT EXISTS authors (
        id INTEGER PRIMARY KEY,
        name TEXT
    )
''')

# Create another table for books with a foreign key reference to authors
cursor.execute('''
    CREATE TABLE IF NOT EXISTS books (
        id INTEGER PRIMARY KEY,
        title TEXT,
        author_id INTEGER,
        FOREIGN KEY (author_id) REFERENCES authors(id)
    )
''')

Save and Close: Just like you'd close your notebook after jotting down your thoughts, it's important to save changes and close the connection when you're done.

# Commit changes and close connection
conn.commit()
conn.close()

Best Practices for Crafting Your Database

Creating a database is like building a puzzle – each piece needs to fit just right. Here are some tips to help you create a well-organized and efficient database:

Plan Ahead: Before you dive in, sketch out what you want to store in your database. It could be anything – from your book collection to your favorite recipes.
Organize Information: Keep things tidy by splitting your data into logical sections. It's like sorting your LEGO pieces into different boxes – it makes building easier!
Use IDs for Every Table: Just as you have your own unique ID, every table in your database should have its own ID. This helps keep everything in order and makes it easier to connect different pieces of data.
Choose Clear Names: Naming is key! Use names that describe your data, so you don't get confused later. It's like labeling folders in your cabinet.
Avoid Data Duplication: Just as you wouldn't make multiple copies of the same recipe, avoid duplicating data in your database. This saves space and keeps things neat.
Stay Backed Up: Imagine your database is a precious family album. Don't forget to make regular backups to ensure your memories are safe.
Be Patient: Building a database takes time and practice. Don't worry if things don't click right away – you'll get the hang of it!

Exploring Table Joins: Connecting the Dots

Now, let's dive a bit deeper and talk about table joins. Imagine you have two tables – one for your books and another for authors. You want to see which author wrote which book. This is where table joins come in handy.

Primary and Foreign Keys: Think of primary keys as special IDs for each table, and foreign keys as links that connect one table to another. In our example, the author's ID in the "authors" table would be a foreign key in the "books" table.
Inner Join: It's like putting together a puzzle. An inner join shows you only the pieces that fit perfectly in both tables.

# Join the "books" and "authors" tables on author_id
query = '''
    SELECT books.title, authors.name
    FROM books
    INNER JOIN authors ON books.author_id = authors.id
'''
cursor.execute(query)

# Fetch and print the results
results = cursor.fetchall()
for title, author in results:
    print(f"Title: {title}, Author: {author}")

Output:

Title: The Great Gatsby, Author: F. Scott Fitzgerald
Title: To Kill a Mockingbird, Author: Harper Lee
Title: 1984, Author: George Orwell

Left Join: This is like a treasure hunt – you get all the pieces from one table and only the matching pieces from the other.

# Get all books and their authors, even if an author is missing
query = '''
    SELECT books.title, authors.name
    FROM books
    LEFT JOIN authors ON books.author_id = authors.id
'''
cursor.execute(query)

# Fetch and print the results
results = cursor.fetchall()
for title, author in results:
  print(f"Title: {title}, Author: {author}")

Output:

Title: The Great Gatsby, Author: F. Scott Fitzgerald
Title: To Kill a Mockingbird, Author: Harper Lee
Title: 1984, Author: George Orwell
Title: Brave New World, Author:

Right Join: This is similar to the left join, but it retrieves all records from the right table and matching records from the left table.

# Get all authors and their books, even if a book is missing
query = '''
    SELECT authors.name, books.title
    FROM authors
    RIGHT JOIN books ON authors.id = books.author_id
'''
cursor.execute(query)

# Fetch and print the results
results = cursor.fetchall()
for author, title in results:
    print(f"Author: {author}, Title: {title}")

Output:

Author: F. Scott Fitzgerald, Title: The Great Gatsby
Author: Harper Lee, Title: To Kill a Mockingbird
Author: George Orwell, Title: 1984
Author: , Title: Brave New World

Wrapping Up

And there you have it, a beginner-friendly guide to using databases with Python! You don't need to be a tech wizard to start working with databases – Python is your friendly companion, guiding you every step of the way. So go ahead, open that digital treasure chest, organize your data, and even connect the dots with table joins. Happy exploring!

A Beginner's Guide to Using Fetch in React: Making Data Requests Made Easy

Tony Hunter — Sat, 01 Jul 2023 20:05:21 +0000

Introduction:
In the world of web development, React has emerged as a popular JavaScript library for building user interfaces. One crucial aspect of creating dynamic web applications is the ability to fetch data from external sources. In this blog, we'll explore the fundamentals of using the fetch function in React, enabling you to effortlessly retrieve data and incorporate it into your projects. So, let's dive in and learn how to harness the power of Fetch in React!

Understanding Fetch:
Fetch is a built-in web API in modern browsers that allows us to make asynchronous HTTP requests. It provides an intuitive and straightforward way to retrieve resources, such as JSON data, from servers. React, being a JavaScript library, readily integrates with Fetch, making it a valuable tool for fetching and handling data in your React applications.

Importing Fetch:
Before we start utilizing Fetch in our React project, we need to import it. Fetch is already available as a global function in modern browsers, so there's no need to install any external packages. You can simply use it directly in your code without any additional setup.

// Importing Fetch in a React component
import React, { useEffect, useState } from 'react';

function MyComponent() {
  // Fetch data example
  useEffect(() => {
    fetch('https://api.example.com/data')
      .then(response => response.json())
      .then(data => {
        // Process the data
      })
      .catch(error => {
        // Handle errors
      });
  }, []);

  return <div>My Component</div>;
}

Fetching Data:
To make a data request using Fetch, we invoke the Fetch function and pass in the URL of the resource we want to retrieve. Fetch returns a Promise that resolves to the Response object representing the server's response to our request.

// Fetching data with Fetch
fetch('https://api.example.com/data')
  .then(response => {
    // Handle the response
  })
  .catch(error => {
    // Handle errors
  });

Handling the Response:
Once we have the Response object, we can extract the data from it. By default, the Response object does not contain the actual data we're interested in; instead, it provides a set of methods to handle the response. We can use these methods to parse the data, check the status of the request, and access headers.

Parsing Data:
Most commonly, the data we fetch will be in JSON format. To extract the JSON data from the Response object, we can use the .json() method. This method also returns a Promise, so we can chain it with other asynchronous operations or use the async/await syntax for cleaner code.

// Parsing JSON data from the Response object
fetch('https://api.example.com/data')
  .then(response => response.json())
  .then(data => {
    // Process the JSON data
  })
  .catch(error => {
    // Handle errors
  });

Handling Errors:
When working with Fetch, it's important to consider error handling. Fetch only rejects its Promise when a network error occurs, such as a failed DNS lookup or a CORS issue. HTTP errors like 404 or 500 are not considered network errors and won't cause the Promise to reject. To handle such errors, we can use the ok property of the Response object, which returns true if the response was successful or false otherwise.

Incorporating Fetch in React Components:
To make use of Fetch in a React component, we typically invoke it within lifecycle methods or React Hooks. For example, we can fetch data when the component mounts using the useEffect Hook or when a certain event occurs, such as a button click. Once we have the data, we can update the component's state using useState or pass it as props to child components for rendering.

// Incorporating Fetch in a React component
import React, { useEffect, useState } from 'react';

function MyComponent() {
  const [data, setData] = useState(null);

  useEffect(() => {
    fetch('https://api.example.com/data')
      .then(response => response.json())
      .then(data => {
        setData(data);
      })
      .catch(error => {
        // Handle errors
      });
  }, []);

  return (
    <div>
      {data ? (
        // Render the fetched data
        <ul>
          {data.map(item => (
            <li key={item.id}>{item.name}</li>
          ))}
        </ul>
      ) : (
        // Render a loading state
        <div>Loading...</div>
      )}
    </div>
  );
}

Conclusion:
In this blog post, we've explored the basics of using Fetch in React to fetch data from external sources. We learned how to import Fetch into our React projects, make data requests, handle the response, parse JSON data, and handle errors effectively. By understanding these fundamental concepts, you'll be well-equipped to incorporate data fetching capabilities into your React applications. Fetch provides a powerful tool for retrieving and working with data, helping you create dynamic and interactive web experiences. So, go ahead and harness the potential of Fetch in your React projects, and happy coding!

Simplifying JavaScript Code with Arrow Functions

Tony Hunter — Fri, 26 May 2023 05:27:26 +0000

Introduction:
JavaScript arrow functions, have changed the landscape in the way developers are able to write functions. They provide a concise and expressive syntax, making code more readable and reducing extra jargon. I will explore the key features and benefits of arrow functions, along with a few examples.

Arrow Function Syntax:
The syntax of arrow functions is straightforward. Instead of the traditional function keyword, we use the arrow (=>) notation. Here’s a simple example:

// Traditional function
function multiply(a, b) {
return a * b;
}

// Arrow function
const multiply = (a, b) => a * b;

Conciseness and Readability:
Arrow functions offer a shorter syntax, eliminating the need for curly braces and the return keyword in certain cases. For single-line functions, we can implicitly return the result. This enhances code readability and reduces unnecessary verbosity:

// Traditional function
function square(x) {
return x * x;
}

// Arrow function
const square = x => x * x;

Lexical this Binding:
One significant advantage of arrow functions is their lexical binding of the “this” keyword. Unlike regular functions, arrow functions don’t have their own this value. Instead, they inherit this from the surrounding context. This simplifies the handling of this scoping issues:

const person = {
name: 'John',
greet: function() {
setTimeout(() => {
console.log(Hello, ${this.name}!);
}, 1000);
}
};

person.greet(); // Outputs: Hello, John!

Use Cases:
Arrow functions are particularly useful in scenarios such as array manipulation, event handlers, and callbacks. They provide a much cleaner way to format your code in these situations:

// Array manipulation
const numbers = [1, 2, 3, 4, 5];
const squaredNumbers = numbers.map(num => num * num);

// Event handler
button.addEventListener('click', () => {
console.log('Button clicked!');
});

// Callback function
fetchData(url, data => {
console.log('Data received:', data);
});

Conclusion:
JavaScript arrow functions simplify code and improve readability by offering a concise syntax and lexical this binding. With their streamlined structure, they are particularly useful in scenarios where brevity and clarity are desired. By leveraging the power of arrow functions, developers can write cleaner, more expressive JavaScript code.

While arrow functions bring many benefits, it’s important to note that they may not be suitable for every situation. Understanding their limitations and appropriate use cases will help developers make informed decisions when choosing between arrow functions and traditional function syntax.

JavaScript vs. Java: Choosing the Right Language for First-Time Users

Tony Hunter — Mon, 22 May 2023 05:41:12 +0000

Introduction:
When it comes to programming, beginners often find themselves faced with a critical decision: which programming language should they start with? Two popular options are JavaScript and Java. While their names may sound similar, these languages have distinct characteristics and use cases. In this blog post, we will explore the advantages and considerations of using JavaScript and Java for first-time users, helping you make an informed decision based on your goals and preferences.

JavaScript: The Versatile Web Language

JavaScript is a high-level programming language primarily used for web development. It runs on the client side and enables interactive elements on websites. Here are a few reasons why JavaScript might be a good choice for first-time users:

Ease of Use: JavaScript has a simpler syntax compared to many other languages, making it more accessible for beginners. It is forgiving and allows for flexible coding styles, enabling newcomers to focus on learning core programming concepts without getting bogged down by complex syntax rules.
Immediate Feedback: One of the greatest advantages of JavaScript is its ability to run directly in the web browser. This means that beginners can instantly see their code in action without the need for compiling or setting up an elaborate development environment. This immediate feedback loop helps accelerate the learning process.
Abundance of Learning Resources: JavaScript is an incredibly popular language, and as a result, there is a vast array of learning resources available, including tutorials, documentation, online communities, and coding challenges. Beginners can easily find help and guidance while exploring JavaScript's potential.
Java: The Versatile Enterprise Language

Java, on the other hand, is a general-purpose, high-level programming language that can be used for a wide range of applications. It is commonly used in enterprise environments and is known for its scalability and robustness. Here are a few reasons why Java might be a good choice for first-time users:

Object-Oriented Programming (OOP): Java is an object-oriented language, which means it focuses on encapsulating data and functionality into objects. OOP is a fundamental programming paradigm, and learning it with Java can provide a strong foundation for understanding other languages that follow similar principles.
Career Opportunities: Java has been a staple in the software development industry for decades, and it continues to be in high demand. Learning Java can open doors to various job opportunities, particularly in enterprise software development.
Strong Community and Libraries: Java has a vast community of developers and a rich ecosystem of libraries and frameworks that can be leveraged to build complex applications. This support network ensures that beginners have access to valuable resources and can collaborate with others in their learning journey.
Considerations for Both Languages:

While both JavaScript and Java have their merits, there are a few factors to consider before making your decision:

Use Cases: JavaScript is primarily used for web development, whereas Java can be used for a broader range of applications, including desktop, mobile, and server-side development. Consider your long-term goals and the type of projects you wish to pursue.
Learning Curve: While JavaScript may be easier to get started with, Java's object-oriented nature and stricter syntax can present a steeper learning curve. Evaluate your comfort level with learning new concepts and languages.
Future Adaptability: The technology landscape is ever-evolving. JavaScript has gained immense popularity in recent years, thanks to frameworks like React and Node.js. However, Java's strong presence in enterprise environments and its continued relevance cannot be overlooked.
Conclusion:
Choosing between JavaScript and Java for your first programming language largely depends on your goals, preferences, and the type of projects you wish to pursue. If you're interested in web development, JavaScript provides an excellent starting point with its simplicity and wide range of applications. On the other hand, if you're aiming for enterprise software development or want to learn the concepts of object-oriented programming, Java might be the right choice.

Ultimately, the most important aspect is to dive into programming and start building projects, regardless of the language you choose. The skills and knowledge gained from your initial language will serve as a strong foundation for exploring other programming languages in the future. Happy coding!