In software development, it's beneficial to break your application into small, isolated units. This approach allows you to write independent tests to check all parts of your application, ensuring that they behave as expected. Also, if a test fails, you can easily isolate and troubleshoot the area of the code that has the bug without tampering with the rest of your application.

Python provides built-in support for unit testing through the unittest testing framework. There are also other third-party testing frameworks that you can use for your unit testing, such as pytest.

This article focuses on how to use the unittest framework to write tests for your Python applications and why developers often prefer it.

To get the best out of this article, you should have a basic understanding of the Python programming language.

Why Do Developers Prefer to Use unittest?

While there are many frameworks for unit testing in the Python ecosystem, many developers still prefer the built-in unittest due to its compelling advantages.

First, the unittest module is part of Python's standard library. This ensures immediate availability and compatibility across various environments without extra dependencies. The seamless integration with various environments makes it convenient for developers to use unittest without installing additional packages.

Second, as a long-standing framework within the Python ecosystem, unittest benefits from familiarity and longevity. Many developers are already used to its API and structure, making it a reliable choice for testing.

Third, most integrated development environments (IDEs) such as PyCharm offer built-in support for unittest. This improves developer productivity and streamlines the testing process, allowing for easier test management and execution.

Fourth, the framework has comprehensive and well-maintained documentation. This provides detailed guidance and examples, aiding developers in effectively using unittest for their testing needs.

Finally, many existing Python projects use unittest for testing, ensuring compatibility with legacy codebases. This widespread adoption allows developers to maintain and extend older projects without needing to introduce and adapt to a new testing framework.

How to Write Unit Tests with unittest

Unit testing with unittest involves creating test cases to verify the functionality of individual units of your code. Each test case is defined by subclassing unittest.TestCase. This allows you to inherit the several methods provided by the TestCase class.

Some of the methods provided by the TestCase class are assert methods. These assert methods allow you to check whether the actual result of a function or operation matches the expected result, or whether certain conditions are met. If an assertion fails, the test is marked as failed, and you will receive an error message.

See Classes and functions for detailed information about the different methods provided by the TestCase class.

Now, let's use two of the assert methods to write tests for a simple calculator program. First, create a new folder (directory), named unit-testing. Then, create a file named calculator.py within your unit-testing folder. Now, copy the following code into your calculator.py file:

def add(x, y):
    """add numbers"""
    return x + y

def subtract(x, y):
    """subtract numbers"""
    return x - y

def divide(x, y):
    """divide numbers"""
    return x / y

def multiply(x, y):
    """multiply numbers"""
    return x * y

Notice that instead of having your calculator program within a single function, we broke it into four independent functions (units). This is to ensure that each part of the program is independently tested. So if any of the units gives an error during testing, you can easily identify that unit and troubleshoot it without tampering with the other parts of your program.

As earlier mentioned, testing with unittest involves creating a subclass of the unittest.TestCase class and then defining methods within the subclass to test individual units of your program.

To show how this works, let's write a test for the add function in your calculator program. In your unit-testing folder, create a new file named test_calculator.py and then copy the following code into it:

import unittest
import calculator

class TestCalculator(unittest.TestCase):
    def test_add(self):
        self.assertEqual(calculator.add(1, 2), 3)
        self.assertEqual(calculator.add(-1, 1), 0)
        self.assertEqual(calculator.add(-1, -1), -2)
        self.assertEqual(calculator.add(0, 0), 0)

In lines one and two of your code, you imported the unittest and your calculator modules. You then created a TestCalculator class, which inherits from the TestCase class.

In line five of your code, you defined a test_add method within your class. The method just like every instance methods in Python takes self as its first argument. Since self is a reference of the TestCalculator class, it can access the assertEqual method provided by the TestCase class, which TestCalculator inherits from.

The assertEqual method checks if two values are equal. It has the following syntax:

self.assertEqual(first, second, msg=None)

In the preceding syntax, first represents the value you want to test against the second value. msg is optional and it represents a custom message that you will receive if the assertion fails. If you don't provide a value for msg, you will receive a default message.

Now, let's use the explanation of the syntax to explain the use of assertEqual in your test_add method. In your first assertion, self.assertEqual(add(1, 2), 3) checks if the result of add(1, 2) is equal to 3. If the function returns 3, the test passes. Otherwise, it fails and outputs a message indicating the mismatch. This explanation is the same for the rest of your assertions.

Also, notice that you tested just representative values in your test_add method. This ensures that your test covers a wide range of possible inputs without redundant code. Here is a breakdown of the representative values in your test_add method:

• The addition of two positive numbers (self.assertEqual(calculator.add(1, 2), 3)).

• The addition of a negative number and a positive number (self.assertEqual(calculator.add(-1, 1), 0)).

• The addition of two negative numbers (self.assertEqual(calculator.add(-1, -1), -2)).

• The addition of two zeros (self.assertEqual(calculator.add(0, 0), 0)).

Now, to run your test, navigate to the unit-testing directory in your terminal and run the following command:

python -m unittest test_calculator.py

Running the preceding command will give you the following message in your terminal:

.
----------------------------------------------------------------------
Ran 1 test in 0.000s

OK

The output indicates that you ran a single test and it was successful.

To ensure that your test is working as expected, you go back to your calculator.py file and change the addition (+) operator in your add function to subtraction (-), like this:

def add(x, y):
    """add numbers"""
    return x - y

Once you've made the changes, running your test again will raise an AssertionError showing that your test failed:

Traceback (most recent call last):
  File ".../test_calculator.py", line 6, in test_add
    self.assertEqual(calculator.add(1, 2), 3)
AssertionError: -1 != 3

----------------------------------------------------------------------
Ran 1 test in 0.000s

You may be wondering why you have to include the unittest module in your command instead of running python test_calculator.py. That's because you are yet to make your test_calculator.py file a standalone script. So running python test_calculator.py won't give you any output.

To make your test_calculator.py executable as a standalone script, you need to add the following to the bottom of your test_calculator.py file:

if __name__ == "__main__":
    unittest.main()

Also, the unittest module requires that you start the name of your test methods with the word test, otherwise, your test won't run as expected.

To try this, change the name of your test_add method to add_test like this:

class TestCalculator(unittest.TestCase):
    def add_test(self):
        self.assertEqual(calculator.add(1, 2), 3)
        self.assertEqual(calculator.add(-1, 1), 0)
        self.assertEqual(calculator.add(-1, -1), -2)
        self.assertEqual(calculator.add(0, 0), 0)

Now, if you run the command python test_calculator.py, you will get a message similar to this:

----------------------------------------------------------------------
Ran 0 tests in 0.000s

OK

Notice that the preceding output shows that zero tests ran. Now, change your method's name back to test_add. Also, change the operator in the add function of your calculator.py back to addition (+). Now, rerun the test with the command python test_calculator.py and compare your output to the preceding output.

It's a common practice for developers to handle invalid input by raising exceptions. So, it's important to write tests that check for these exceptions.

For example, Python will raise a ZeroDivisionError if you try to divide any number by zero. You can use the unittest module to test for such errors.

Now, modify your test_calculator.py file to include a test method for your divide function:

import unittest
import calculator

class TestMathOperations(unittest.TestCase):
    def test_add(self):
        self.assertEqual(calculator.add(1, 2), 3)
        self.assertEqual(calculator.add(-1, 1), 0)
        self.assertEqual(calculator.add(-1, -1), -2)
        self.assertEqual(calculator.add(0, 0), 0)

    def test_divide(self):
        self.assertEqual(calculator.divide(10, 2), 5)
        self.assertEqual(calculator.divide(9, 3), 3)
        self.assertEqual(calculator.divide(-6, 2), -3)
        self.assertEqual(calculator.divide(0, 1), 0)
        with self.assertRaises(ZeroDivisionError):
            calculator.divide(10, 0)

if __name__ == "__main__":
    unittest.main()

In the preceding code, your new test_divide method tests representative values just like your test_add method. But there is new code at the end that uses assertRaises. assertRaises is another assert method provided by unittest to check if your code raises an exception. Here, you used the method to check for ZeroDivisionError.

So, if you run the tests now, you will get a message showing two dots (..) and indicating that you ran two successful tests:

..
----------------------------------------------------------------------
Ran 2 tests in 0.000s

OK

Conclusion

This article has taught you the basics of unit testing in Python using the unittest testing framework.

You've learned the importance of independently testing individual units of your application and the reasons unittest is still a popular choice among Python developers. Also, you've learned how to write basic test cases for the add and divide functions in your simple calculator program.

With this knowledge, you can now confidently create tests that ensure your code behaves as expected, making it more robust and maintainable. I encourage you to apply these lessons by writing tests for the remaining subtract and multiply functions in your calculator program.

Like many other programming languages, Python supports both OOP and functional programming. However, OOP becomes valuable when writing large-sized and complex programs.

In this article, you will learn the benefits of OOP in Python, how to define a class, class and instance attributes, and instance methods. You will also learn the concept of encapsulation and how to implement inheritance between classes in Python.

To fully understand this article, you should have the following prerequisites:

• Basic knowledge of the Python programming language.

• Familiarity with the concepts of functions and objects in programming.

• Experience working with a code editor or integrated development environment (IDE).

• Basic understanding of how to use a command-line terminal or console.

Now let's dive in.

Why Use Object-Oriented Programming?

Object-oriented programming (OOP) offers several benefits when organizing and managing code. By grouping related data and functions into logical classes, OOP promotes code structure and simplifies maintenance, especially as programs grow in size and complexity. The modular approach makes it easier to understand, modify, and reuse code, thereby reducing development time.

Another benefit of OOP is its ability to provide a clear and relatable programming style, which can be more helpful for developers. The use of objects and the relationships between them mirror real-world concepts. This makes it easier to reason about code and design complex systems.

Finally, OOP's concepts such as encapsulation and inheritance, contribute to code robustness by promoting data protection and code reusability.

What is a Class in Python?

OOP in Python heavily relies on the concept of class. You can think of a class as a blueprint that is used to create objects. To illustrate this, imagine that you have a blueprint for a speaker. You can use this blueprint to build multiple speakers. Each speaker that is created using the blueprint is an instance of the blueprint. Also, each created speaker has its attributes such as color, model, and name. They will also have their methods showing a certain kind of behavior such as volume up and volume down.

How to Define a Class in Python

To define a class, you have to use the class keyword, provided by Python, then followed by the name of the class and a colon:

class ClassName:
    pass

Now using our earlier illustration, let’s create a class named Speaker. In your code editor, create a file named classes.py and copy the following lines of code into it:

class Speaker:
    pass

speaker_one = Speaker()
print(speaker_one)

In the preceding code, you defined a class named Speaker without any attributes or methods. You used the keyword pass in the class body. In Python, the pass keyword does nothing and is usually used as a placeholder.

In line four of the code, you created an instance of the Speaker class and assigned it to the variable speaker_one. This process is also known as instantiating an object from a class. You then printed speaker_one in line five.

Now run the code by running the command python classes.py in your terminal. You will get an output similar to this in your terminal:

<__main__.Speaker object at 0x10087f8e0>

The output shows that speaker_one is an object. 0x10087f8e0 in the output shows the memory address where Python stores the object on your computer.

The memory address in your terminal output will be different.

You can create several more instances from the Speaker class and they will all be different from one another. To verify this, let’s use the equality comparison (\==) operator. In your classes.py file, delete print(speaker_one) and add the following to the bottom of your code:

speaker_two = Speaker()

if speaker_one == speaker_two:
    print("speaker one is the same as speaker two")
else:
    print("speaker one is different from speaker two")

Now run python classes.py in your terminal. You will get the following output:

speaker one is different from speaker two

Class and Instance Attributes

In this section, you'll add attributes to your Speaker class. You can see attributes as data stored within an object. While class attributes are common to all instances created from your class, instance attributes are unique to each instance.

Now modify your classes.py file by replacing your code with the following:

class Speaker:
    brand = "Beatpill" # class attribute

    def __init__(self, color, model):
        self.color = color # instance attribute
        self.model = model # instance attribute

You should already be familiar with line one of your new code. In line two, you defined a class attribute, named brand, and assigned it the value Beatpill. Class attributes are variables that belong to the class itself, rather than to individual instances of the class. The effect of class attributes is that all instances you create from your class will inherit and share that class attribute and its value. In this case, every instance you create from your Speaker class will share the same brand value.

Line four of your code defines an __init__ method, which takes in three parameters—self, color, and model. This method will be called anytime you create a new instance from your Speaker class. The self parameter is a reference to the Speaker class and it's a convention in Python to always have it as the first parameter in a __init__ method. Line five and six set instance attributes, color, and model to your Speaker class.

So, every time you create a new instance from your class, you have to provide arguments for your color and model attributes. Not doing this will result in an error.

Now add the following to the bottom of your code:

speaker_one = Speaker("black", "85XB5")
speaker_two = Speaker("red", "Y8F33")

print(f"speaker one is {speaker_one.color} while speaker two is {speaker_two.color}")

By adding the preceding code, you created two instances of the Speaker class—speaker_one and speaker_two. The arguments in each instance represent the values of their color and model attributes. You then printed a message that displays the color attribute of each object. Now, if you run the command python classes.py in your terminal, you will get the output:

speaker one is black while speaker two is red

To see that both instances share the same brand class attribute, modify your print() function like this:

print(
    f"speaker one is {speaker_one.color} while speaker two is {speaker_two.color}",
    speaker_one.brand,
    speaker_two.brand,
    sep="\n",
)

Now run python classes.py and you will get the following output:

speaker one is black and speaker two is red
Beatpill
Beatpill

Instance Methods

In addition to class and instance attributes, classes can also have methods, known as instance methods. Instance methods are functions defined within a class that operate on instances of the class. They use the class and instance attributes to provide behavior and functionality to the objects.

To add instance methods, modify your code file as follows:

class Speaker:
    brand = "Beatpill"

    def __init__(self, color, model):
        self.color = color
        self.model = model

    def power_on(self):
        print(f"Powering on {self.color} {self.model} speaker.")

    def power_off(self):
        print(f"Powering off {self.color} {self.model} speaker.")


speaker_one = Speaker("black", "85XB5")
speaker_two = Speaker("red", "Y8F33")

In the example above, we've added two instance methods—power_on() and power_off(). These methods, just like the __init__ method, take self as the first argument.

The power_on() method prints a message indicating that the speaker of the given color and model is being powered on. Similarly, the power_off() method prints a message about powering off the speaker.

To call these methods, add the following to the bottom of your file:

speaker_one.power_on()
speaker_two.power_off()

Now run python classes.py in your terminal and you will get the following output:

Powering on black 85XB5 speaker.
Powering off red Y8F33 speaker.

Encapsulation in Python

Encapsulation is one of the core concepts of OOP. It refers to the bundling of data (attributes) and methods within a class. Encapsulation provides data protection and control over how the code interacts with an object's internal state.

You can achieve encapsulation in Python by defining private attributes and methods within a class. By convention, private attributes and methods are prefixed with a single underscore (_). While Python does not have strict private modifiers like some other languages, the underscore prefix serves as a warning to other developers not to access or modify the attributes and methods directly from outside the class.

Here's an example of encapsulation in Python:

class Speaker:
    brand = "Beatpill"

    def __init__(self, color, model):
        self._color = color  # Private attribute
        self._model = model  # Private attribute

    def power_on(self):
        print(f"Powering on {self._color} {self._model} speaker.")

    def power_off(self):
        print(f"Powering off {self._color} {self._model} speaker.")

    def get_color(self):
        return self._color

    def set_color(self, new_color):
        self._color = new_color


speaker_one = Speaker("black", "85XB5")
speaker_one.power_on()

# Accessing a private attribute directly (not recommended)
print(speaker_one._color)

# Accessing a private attribute using the getter method (recommended)
print(speaker_one.get_color())

# Modifying a private attribute using the setter method (recommended)
speaker_one.set_color("white")
print(speaker_one.get_color())

In the preceding example, the color and model attributes are private attributes of the Speaker class. Although it is possible to access and modify these attributes directly from outside the class by using, for example, print(speaker_one._color), this practice is discouraged. Doing so violates encapsulation and can lead to unintended behavior or data corruption.

Instead, the class provides getter get_color() and setter set_color() methods to access and modify the private attributes in a controlled manner. These methods act as an interface for interacting with the object's internal state, ensuring data integrity and enabling additional validation.

Encapsulation promotes code modularity, maintainability, and data protection by separating the internal state from the public interface (methods). It allows you to change the internal state without affecting the code that uses the class, as long as the public interface remains the same.

Inheritance in Python

Inheritance is another core concept of OOP. It allows classes to inherit attributes and methods from other classes. The new class inherits attributes and methods from the existing class, known as the parent or base class. The new class is called the child or derived class.

Inheritance promotes code reuse by allowing the child class to inherit and extend the functionality of the parent class. This helps in creating hierarchical relationships between classes and organizing code in a more structured and logical manner.

In Python, inheritance is implemented using the following syntax:

class DerivedClass(BaseClass):
    # Derived class methods and attributes

To see how inheritance works, modify your code as follows:

class Speaker:
    brand = "Beatpill"

    def __init__(self, color, model):
        self._color = color
        self._model = model

    def power_on(self):
        print(f"Powering on {self._color} {self._model} speaker.")

    def power_off(self):
        print(f"Powering off {self._color} {self._model} speaker.")

# Add a SmartSpeaker class and make it inherit from the Speaker class
class SmartSpeaker(Speaker):
    def __init__(self, color, model, voice_assistant):
        super().__init__(color, model)
        self._voice_assistant = voice_assistant

    def say_hello(self):
        print(f"Hello, I am {self._voice_assistant}")


# Create an instance of the SmartSpeaker class
smart_speaker = SmartSpeaker("black", "XYZ123", "Alexa")
smart_speaker.power_on()  # Inherited from Speaker
smart_speaker.say_hello()

In the preceding code, the SmartSpeaker class is derived from the Speaker class. The SmartSpeaker class inherits the attributes and methods of the Speaker class.

The __init__ method of the SmartSpeaker class calls the __init__ method of the Speaker class using super().__init__(color, model). This ensures that the inherited _color and _model attributes are properly initialized. Also, the SmartSpeaker class has its own attribute _voice_assistant, and a new method say_hello.

Now run python classes.py in your terminal and you will get the following output:

Powering on black XYZ123 speaker.
Hello, I am Alexa

Conclusion

Throughout this article, we highlighted the benefits of Object-Oriented Programming (OOP) and demonstrated how to define classes, create and use instance attributes and methods. We provided practical examples to illustrate the implementation of classes in Python, as well as key OOP concepts such as encapsulation and inheritance.

Applying the lessons covered in this article will help you improve your Python programming experience and increase the efficiency and maintainability of your code.

References and Further Reading

• https://en.wikipedia.org/wiki/Object-oriented_programming

• https://realpython.com/python3-object-oriented-programming/

• https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Objects/Object-oriented_programming

• https://docs.python.org/3/tutorial/classes.html

• https://realpython.com/python-classes/

• https://realpython.com/python-double-underscore/

Websites must be able to store and retrieve data from databases. Django makes provisions for this. By default, Django operates a Relational Database Management System.

A relational database is a type of database that stores and provides access to data points that are related to one another. Relational databases are based on the relational model, an intuitive, straightforward way of representing data in tables. In a relational database, each row in the table is a record with a unique ID called the key. (Source: Oracle Cloud)

A major advantage of a Relational Database Management System is being able to define the types of relationships between the different data held in the different tables of your database.

This tutorial shows you how you can define the relationships between your Django models. To get the most out of this tutorial, you should have a basic understanding of the Django web framework, especially Django file structure and models.

Different Types of Model Relationships in Django

Each model in a Django application represents a database table. This means that you can define the kind of relationship you want between the different models in your Django application.

Django supports three main types of relationships between its models. They're as follows:

One-to-One Relationship

A one-to-one relationship means that a record in one table relates to a single record in another table.

An instance of this is if you have a Django model that defines users. This model can then have a one-to-one relationship with another Django model, which defines users' profiles. In this scenario, a user can have only one profile and a profile can be associated with only one user.

The following diagram illustrates a one-to-one relationship:

A diagram showing a one-to-one relationship between a User model and a Profile model.

Django provides you with OneToOneField, which helps define a one-to-one relationship between two different models.

The following code shows you how you can define a one-to-one relationship in Django. Go to your <app>/models.py and write the following code:

from django.db import models

class User(models.Model):
    name = models.CharField(max_length=50)

    def __str__(self):
        return str(self.name)

class Profile(models.Model):
    user = models.OneToOneField(
        User,
        on_delete=models.PROTECT,
        primary_key=True,
    )
    language = models.CharField(max_length=50)
    email = models.EmailField(max_length=70,blank=True,unique=True)

    def __str__(self):
        return str(self.email)

Let's see what's going on in the above code:

1. Line one imports the sub-module models from the django.db module.

2. Line three defines a Django model named User.

3. Line four defines a name property within the User model, and the keyword CharField is how you define text with a limited number of characters.

4. Line six and seven is a special method within the User model and returns a string representation of the User model that includes the name property.

5. Line nine defines a Django model named Profile.

6. Line ten defines a one-to-one relationship between the Profile model and the User model using the OneToOneField keyword.

7. Lines eleven and twelve define the properties language and email within the Profile model.

8. Line twelve and thirteen is a special method within the Profile model and returns a string representation of the Profile model that includes the email property.

Many-to-one Relationship

In a many-to-one relationship, a record in one table relates to multiple records in another table. Some resources refer to a many-to-one relationship as a one-to-many relationship. These two mean the same thing.

An example of a one to many relationship is the relationship between an author and their published books. While an author can have more than one book to their name, it's less common to find a book with more than one author. You can see this kind of relationship as a parent-child relationship.

The following diagram illustrates a one-to-many relationship:

A diagram showing a one-to-many relationship between an Author model and a Book model.

Django provides you with ForeignKey, which helps define a many-to-one relationship between two different models.

The following code shows you how you can define a many-to-one relationship in Django. Go to your <app>/models.py and write the following code:

from django.db import models

class Author(models.Model): 
    name = models.CharField(max_length=50, blank=False, unique=True)

    def __str__(self):
        return str(self.name)

class Book(models.Model):
    author = models.ForeignKey(
        Author,
        on_delete=models.PROTECT,
        blank=False
    )

    title = models.CharField(max_length=100)

    def __str__(self):
        return self.title

This code is similar to the code in the first example. However, in line ten here, the ForeignKey keyword is what you use to define a many-to-one relationship between two Django models. In this case, the current model will have a many-to-one relationship with the Author model.

Many-to-Many Relationship

In a many-to-many relationship, multiple records in one table relate to many records in another table. For instance, you may have a collection model in your application, in which one collection has many books within it. In the same vein, a book may belong to several collections.

The following diagram illustrates a many-to-many relationship:

A diagram showing a many-to-many relationship between a Collection model and a Book model.

Django provides you with a ManyToManyField which helps define a many-to-many relationship between two different models.

The following code shows you how you can define a many-to-many relationship in Django. Go to your <app>/models.py and enter the write the following code:

from django.db import models

class Collection(models.Model):
  name = models.CharField(max_length=50)

  def __str__(self):
        return str(self.name)

class Book(models.Model):
  collection = models.ManyToManyField(Collection)

  title = models.CharField(max_length=100)

  def __str__(self):
        return str(self.title)

In this code sample, the ManyToManyField keyword in line 10 is what you use to define a many-to-many relationship between the Collection and Book models.

Conclusion

Although this tutorial explains the basics of Django model relationships to help you get a basic understanding, real-life projects can get more complicated.

The complexity of your Django model relationships depends on your application's complexity. So before you build your applications, it's important to plan out your database relationships. Doing this saves you lots of time and effort compared to finding problems and backtracking later.

You can refer to each row in a CSV file as a data record. Each data record consists of one or more fields, separated by commas.

This article shows you how to use the Python built-in module called csv to create CSV files. In order to fully comprehend this tutorial, you should have a good understanding of the fundamentals of the Python programming language.

The csv module has two classes that you can use in writing data to CSV. These classes are:

• the csv.writer class

• the csv.DictWriter class

How to Create a CSV File Using the csv.writer Class

You can use the csv.writer class to write data into a CSV file. The class returns a writer object, which you can then use to convert data into delimited strings.

To ensure that the newline characters inside the quoted fields interpret correctly, open a CSV file object with newline=''.

The syntax for the csv.writer class is as follows:

csv.writer(csvfile, dialect=’excel’, **fmtparams)

Now, let me walk you through the meaning of the different parameters used in the syntax.

1. The csvfile parameter represents the csvfile object with the write() method.

2. The optional dialect parameter represents the name of the dialect you can use in writing the CSV file.

3. The optional fmtparams parameter represents the formatting parameters that you can use to overwrite the parameters specified in the dialect.

The csv.writer class has two methods that you can use to write data to CSV files. The methods are as follows:

The writerow() Method

The writerow() method takes in iterable data as its parameter and then writes the data to your CSV file in a single row. One popular usage of the writerow() method is using it to write the field row of your CSV file.

Now let me show you how you can use the writerow() method to write a single row into your CSV file.

In your code editor, create a file with the name profiles1.py. Then write the following code in the file:

import csv

with open('profiles1.csv', 'w', newline='') as file:
    writer = csv.writer(file)
    field = ["name", "age", "country"]

    writer.writerow(field)
    writer.writerow(["Oladele Damilola", "40", "Nigeria"])
    writer.writerow(["Alina Hricko", "23", "Ukraine"])
    writer.writerow(["Isabel Walter", "50", "United Kingdom"])

The explanation for the code in profiles1.py is as follows:

1. Line one imports the Python csv module.

2. Line two is a blank line that separates the imported module from the rest of the code.

3. Line three of the code opens the CSV file in writing (w mode) with the help of the open() function.

4. Line four creates a CSV writer object by calling the writer() function and stores it in the writer variable.

5. Line five creates a variable named fields, which stores a list that consists of strings, each representing the title of a column in the CSV file.

6. Line six and below writes the field data and other data to CSV file by calling the writerow() method of the CSV writer object.

Once you are done, go to your command line terminal and navigate to the directory that has the Python file profiles1.py. Run the following command:

python profiles1.py

You should get a CSV file named profiles1.csv in your working directory with the following text in it:

name,age,country
Oladele Damilola,40,Nigeria
Alina Hricko,23,Ukraine
Isabel Walter,50,United Kingdom

The writerows() Method

The writerows() method has similar usage to the writerow() method. The only difference is that while the writerow() method writes a single row to a CSV file, you can use the writerows() method to write multiple rows to a CSV file.

To see how the writerows() method works, create a file named profiles2.py in your working directory. Then write the following code in the file you created:

import csv

with open('profiles2.csv', 'w', newline='') as file:
    writer = csv.writer(file)
    row_list = [
        ["name", "age", "country"], 
        ["Oladele Damilola", "40", "Nigeria"], 
        ["Alina Hricko", "23" "Ukraine"], 
        ["Isabel Walter", "50" "United Kingdom"],
    ]

    writer.writerows(row_list)

After writing the code in your profiles2.py file, go to your command line terminal and run the following command:

python profiles2.py

Now you should have a CSV file named profiles2.csv in your working directory. The file should have the data in the row_list variable.

How to Create a CSV File Using the csv.DictWriter Class

You can use the csv.DictWriter class to write a CSV file from a dictionary. This is unlike the csv.writer Class, which writes to a CSV file from a list.

The syntax for the csv.DictWriter is as follows:

class csv.DictWriter(csvfile, fieldnames, restval='', extrasaction='raise', dialect='excel', *args, **kwds)

Now let me explain the meaning of the different parameters in the syntax:

1. The csvfile represents the file object with the write() method

2. The fieldnames parameter is a sequence of keys that identify the order in which Python passes the values in the dictionary.

3. The restval parameter is optional and it specifies the value to be written if the dictionary is missing a key in fieldnames.

4. The extrasaction parameter is optional and it specifies the action to take if a key is not found in fieldnames. Setting this parameter to raise, raises a ValueError.

5. The dialect parameter is optional and it represents the name of the dialect you want to use.

The csv.DictWriter class has two methods that you can use to write data to CSV files. The methods are as follows:

The writeheader() Method

Use the writeheader() method to write the first row of your csv file using the pre-specified fieldnames.

To see how the the writeheader() method works, create a new file named profiles3.py in your working directory. Then write the following code in the profles3.py file using your code editor:

import csv 

mydict =[{'name': 'Kelvin Gates', 'age': '19', 'country': 'USA'}, 
         {'name': 'Blessing Iroko', 'age': '25', 'country': 'Nigeria'}, 
         {'name': 'Idong Essien', 'age': '42', 'country': 'Ghana'}]

fields = ['name', 'age', 'country'] 

with open('profiles3.csv', 'w', newline='') as file: 
    writer = csv.DictWriter(file, fieldnames = fields)

    writer.writeheader()

The explanation of the code in profiles3.py is as follows:

1. Line one imports the Python csv module.

2. Line two is a blank space that separates the Python csv module from the rest of the code.

3. Line three stores a list that contains three different dictionaries in a variable named mydict. The dictionaries have the data of different profiles in them.

4. Line seven stores strings, which represent the title of each column of the CSV file that you want to create in a variable named fields.

5. Line nine opens the profiles3.csv file in writing mode using open() function.

6. The csv.DictWriter() function in line ten creates the CSV dictionary writer object.

7. Line twelve passes the list of dictionaries to the writer.writeheader() function to write the pre-defined field names.

Once you are done writing the code, go to your command line terminal and navigate to the directory that has the python file profiles3.py. Run the following command:

python profiles3.py

Now, you should get a CSV file a named profiles3.csv in your working directory that has the following text in it:

name,age,country

The writerows() Method

The writerows() method has a similar usage as the writeheader() method. You can use the method to write all the rows. The method writes only the values and not the keys.

To use the writerows() method, add this line of code to your code in profiles3.py:

writer.writerows(mydict)

Now delete the profiles3.csv in your working directory and re-run the following command in your command line terminal:

python profiles3.py

You should now have a new CSV file named profiles3.csv in your working directory that has the following text in it:

name,age,country
Kelvin Gates,19,USA
Blessing Iroko,25,Nigeria
Idong Essien,42,Ghana

Conclusion

Although CSV got its name from a comma, the comma is just a delimiter that separates the data.

You should know that a comma is a popular delimiter you will get in most CSV files. However, the delimiter could also be something else. For instance, you can use a semi-colon to separate the data instead of a comma.

If you like this tutorial, kindly follow me on Twitter and give me a shout out.

References and Further Reading

• https://docs.python.org/3/library/csv.html?highlight=csv

Jamstack takes advantage of existing technologies – which we'll discuss in a minute. The result is better performance, improved security, and easier scalability for web applications.

In this article, you'll learn what Jamstack means and the benefits of using this approach in your projects.

What is the Jamstack?

Jamstack is a web development architecture. Matt Biilmann, the CEO of Netlify, popularized it with his presentation at Smashing Conference 2016.

Jamstack is an acronym for Javascript, APIs, and Markup, and is a technology stack you use to build your apps.

This is like the MERN stack (MongoDB, ExpressJS, ReactJS and NodeJS) and the MEAN stack (MongoDB, ExpressJS, Angular and NodeJS) – just with different tools.

Now let's discuss the various components of a Jamstack web application:

Javascript

Javascript is the core programming language of the web. It has been around for decades and you can use it both on the client side and the backend with NodeJS.

Javascript is the programming language you use for handling the client side of your Jamstack applications.

APIs

API is an acronym for Application Programming Interface. It's an interface which helps two or more computer programs communicate with each other.

In Jamstack apps, you use APIs to communicate with your backend.

Markup

Markup refers to standard text-encoding systems consisting of a set of symbols inserted into a text document. Examples of markup languages are HTML, XML, and templating languages such as JSX.

In the Jamstack, markup refers to the content of a Jamstack application. Note that we use markup here in its broader sense. It doesn't refer to text content only but also to the assets of the web application, such as images.

Important Features of Jamstack Apps

To consider an application a Jamstack app, it should meet the following conditions:

Distributed Architecture

This refers to the decoupling of the client side from the backend. The client side handles the presentation of the user interface, and the backend handles business logic and data.

Communication between the frontend and backend happens via a dedicated API. This means that a change or upgrade in one will not affect the other. This results in easier maintenance of the entire web application.

Static Sites

It is important for Jamstack applications to serve static web pages and not dynamic ones.

Traditional web applications are dynamic sites. This means that when you request a page, the backend will have to reach a database to retrieve the data. The data is then used to generate HTML files, and then sent back to the client.

The disadvantage of dynamic sites is how long it takes to complete these steps.

For static sites, the pages are already pre-rendered at build time. So every time you request a page, you get the pre-rendered page.

This eliminates the time that dynamic sites spend in obtaining data, generating HTML files, and sending it back to the client. You can serve your static sites from a content delivery network (CDN). This will lead to improved speed and reduced costs.

Examples of static site generators that you can use for your Jamstack web applications include:

• NextJS

• Gatsby

• Hugo

• Jekyll

• Nuxt

Why Should You Use the Jamstack for your Web Applications?

Let's now discuss some of the reasons the Jamstack web architecture has become so popular in recent times and why you should consider adopting it:

Jamstack Apps Are Scalable

You can serve most Jamstack applications from a CDN. This allows for the speedy transfer of assets needed for loading web pages.

As a result of the distributed nature of CDNs, your web application will also be able to handle more traffic at a reduced cost.

Jamstack Apps Are Easy to Maintain

Jamstack applications are easier to maintain since their client side is decoupled from their backends.

This means that you can maintain one part without requiring major modifications to the other.

Jamstack Apps Load Faster

As stated earlier, serving your site from a CDN increases the speed with which it loads.

Also, in Jamstack applications, web pages are prebuilt, saving time that would normally be spent retrieving and generating HTML files every time you make a request.

Jamstack Apps Are Cheaper

Since Jamstack applications are easier to maintain and deploy, they are cheaper compared to their traditional counterparts.

Jamstack Apps Are More Secure

Since you do not have to constantly maintain a server in Jamstack applications and the pages are constructed on read-only files (that is, the pages are static), you can worry less about the security of your applications.

Conclusion

Despite the fact that more and more projects are being built using the Jamstack architecture, we're still in the relatively early stages of its adoption.

I believe that more large and small businesses will adopt it in the near future in place of costly monolithic architectures.

For instance, if you need to store three characteristics each for 10 individuals, having 30 variables individually declared can make your program appear less organized.

So you need a way to group values with similar characteristics together to make your code more readable. And in JavaScript, objects work well for this purpose.

Unlike other data types, objects are capable of storing complex values. Because of this, JavaScript relies heavily on them. So it's important that you become familiar with what an object is, how to create one, and how you can use it before going in-depth into learning JavaScript.

This article will introduce you to the basics of objects, object syntax, the different methods of creating objects, how to copy objects and how to iterate over an object.

In order to get the most out of this article, you need to have at least a basic understanding of JavaScript, particularly variables, functions, and data types.

What Are Objects in JavaScript?

An object is a data type that can take in collections of key-value pairs.

A major difference between an object and other data types such as strings and numbers in JavaScript is that an objects can store different types of data as its values. On the other hand, primitive data types such as numbers and strings can store only numbers and strings, respectively, as their values.

The key, also known as the property name, is usually a string. If any other data type is used as a property name other than strings, it would be converted into a string.

You can visualize an object as a multi-purpose shelf containing space for your gadgets and ornaments as well as a storage space for books, and files.

A shelf with several items in it

The most recognizable feature of an object is the brackets which contain the key-value pair.

const emptyObject = {};
console.log(typeof emptyObject); //'object'

The contents of an object can consist of variables, functions, or both. Variables found in objects are properties, while functions are methods. Methods allow the objects to use the properties within them to perform some kind of action.

For example, in the sample code below, object1.user, object1.nationality and object1.profession are all properties of object1 while object1.myBio() is a method:

const object1 = {
    user: "alex",
    nationality: "Nigeria",
    profession: "Software Enginneer",
    myBio() {
        console.log(`My name is ${this.user}. I'm a               ${this.profession} from ${this.nationality}`)
    }
}
console.log(object1.user); //Alex 
console.log(object1.nationality); //Nigeria 
console.log(object1.profession); //Software Engineer 
console.log(object1.myBio()); //My name is alex. I'm a Software Engineer from Nigeria

The keys in the sample code above are user, nationality and profession while their values are the string values that come after the colons. Also, notice the use of the this keyword. The this keyword simply refers to the object itself.

As mentioned earlier in this article, the value of a property can be any data type. In the following sample code, the values are both arrays and objects:

 const object2 = { 
        users: ["Alex", "James", "Mohammed"], 
        professions: { 
            alex: "software engineer", 
            james: "lawyer", 
            mohammed: "technical writer" 
        } 
    }; 
    console.log(object2.users); //['Alex', 'James', 'Mohammed'] 
    console.log(object2.professions); //{alex: 'software engineer', james: 'lawyer', mohammed: 'technical writer'}

How to Access Objects and Create New Object Properties or Methods in JavaScript

There are two ways to access objects: dot notation and bracket notation. In the previous sample code, we used dot notation to access the properties and methods in object1 and object2.

Also, to create new properties and methods after the declaration of an object, you can use either dot notation or bracket notation. You just have to state the new property and give it a value.

For instance, we can add new properties to object2 like this:

object2.ages = [30, 32, 40];
object2["summary"] = `Object2 has ${object2.users.length} users`;
console.log(object2);
/*
{
    "users": [
        "Alex",
        "James",
        "Mohammed"
    ],
    "professions": {
        "alex": "software engineer",
        "james": "lawyer",
        "mohammed": "technical writer"
    },
    "ages": [
        30,
        32,
        40
    ],
    "summary": "Object2 has 3 users"
}
*/

Similarly, you can use either notation to change the value of an object:

object2.users = ["jane", "Williams", "John"];
object2["age"] = [20, 25, 29]
console.log(object2.users); //['jane', 'Williams', 'John']
console.log(object2.ages) //[20, 25, 29

Although dot notation is the most commonly used to access an object's properties and methods, it has some limitations. Let's look at them now.

You Can't Use Values as Property Names with Dot Notation

If you want to use the value of a variable as a property name in your object, you have to use bracket notation and not dot notation. Whether the variable value is defined at runtime or not is irrelevant.

Runtime is a phase of a computer program in which the program is run or executed on a computer system.

For example:

const object3 = {};
const gadget = prompt("enter a gadget type"); 
object3[gadget] = ["jbl", "sony"]; 
console.log(object3) //(respose entered in prompt): ["jbl","sony"] notice that the property name is the value you enter in the reply to the prompt message

If you define the variable value in your code, and you use dot notation to set that value as a property name of your object, dot notation will create a new property with the variable name instead of with the variable value.

const computer = "brands"
object3.computer = ["hp", "dell", "apple"]
console.log(object3.brands); //undefined
console.log(object3.computer)//['hp', 'dell', 'apple']

object3[computer] = ["hp", "dell", "apple"]
console.log(object3.brands) //['hp', 'dell', 'apple']

Notice the omission of quotes within the square brackets. This is because the brackets took in a variable.

You Can't Use Multi-Word Properties with Dot Notation

Where the property name is a multi-word string then dot notation is insufficient. For instance:

object3.users height = [5.6, 5.4, 6.0];
Console.log(object3.users height); //SyntaxError

A syntax error occurs because JavaScript reads the command as object3.users, but the string height is not recognized so it returns a syntax error.

When using dot notation to access objects, the usual rules of declaring a variable apply. This means that if you want to use dot notation to access an object or create a property, the property name must not start with a number, must not include any spaces, and can only include the special characters $ and _.

To avoid this kind of error, you have to use bracket notation. For instance, you can correct the above sample code like this:

object3["users height"] = [5.6, 5.4, 6.0];  
console.log(object3["users height"]); //[5.6, 5.4, 6]

How to Create Objects with the Object Constructor in JavaScript

There are two methods by which you can create an object: an object literal and the object constructor. The objects used so far as samples in this article are object literals. Object literals work well if you want to create a single object.

But if you want to create more than one object, it is always better to use the object constructor. This allows you to avoid unnecessary repetition in your code and also makes it easier to change the properties of your object.

Basically, constructors are functions whose names are usually capitalized. The capitalization of a constructor name does not have any effect on the object. It is only a means of identification.

You can use a constructor to create a new object by calling the constructor with the new keyword. The new keyword will create an instance of an object and bind the this keyword to the new object.

As earlier mentioned in this article, the this keyword is a reference to the object itself.

An example of an object constructor is:

function Profile(name, age, nationality) { 
    this.name = name; 
    this.age = age; 
    this.nationality = nationality; 
    this.bio = function () { 
        console.log(`My name is ${this.name}. I'm ${this.age} years old. I'm from ${this.nationality}`) 
    } 
};

const oladele = new Profile("Oladele", 50, "Nigeria" );
console.log(oladele.bio()); //My name is Oladele. I'm 50 years old. I'm from Nigeria

How to Create Object Copies in JavaScript

Unlike primitive data types such as strings and numbers, assigning an existing object to another variable will not produce a copy of the original but rather a reference in memory.

What this means is that both the original object and subsequent objects created by assigning the original object as a value are referencing the same item in memory.

This means that a change in the value of any of the objects will also cause a change in the others. For example:

let x = 10;
let y = x;
x = 20;
console.log(x); //20
console.log(y); //10

let object4 = { 
    name: "Alex", 
    age: 40 
}; 
let object5 = object4; 
console.log(object5); //{name: 'Alex', age: 40} 
object4.name = "Jane"; 
console.log(object5); //{name: 'Jane', age: 40}
console.log(object4 === object5); //true

To create a copy of an object, you can use the spread operator.

What is the Spread Operator?

The spread operator is represented by three dots ... . You can use the spread operator to copy the values of any iterable including objects.

An iterable is an object which can be looped over or iterated over with the help of a for...loop. Examples of iterables include objects, arrays, sets, strings, and so on.

To use the spread operator, you will have to prefix it to the object you want to copy from. For instance:

let object6 = {...object5}; 
object5.name = "Willaims"; 
console.log(object5); //{name: 'Willaims', age: 40}
console.log(object6); //{name: 'Jane', age: 40}
console.log(object5 === object6); //false

As you can see, unlike in the previous code sample, where a change in the object4 caused a change in object5, the change in object6 did not result in a change in object5.

How to Use the Object.assign() Method

The Object.assign() method copies all enumerable properties of one object into another and then returns the modified object.

The method takes in two parameters. The first parameter is the target object which takes in the properties copied. The second parameter is the source object which has the properties you want to copy. For instance :

let object7  = Object.assign({}, object6); 
console.log(object7); //{name: 'Jane', age: 40}
console.log(object7); //{name: 'Jane', age: 40}

console.log(object6 === object7); //false
object6.age = 60
console.log(object6); //{name: 'Jane', age: 60}
console.log(object7); //{name: 'Jane', age: 40

You can see from the above sample code that a change in the value of the age property of object6 did not cause a change in the vale of the age property of object7.

Note that both the spread operator and the Object.assign() method can only make a shallow copy of an object.

This means that if you have deeply nested objects or arrays in your source object, only the references to such objects are copied into the target object. So a change in the value of any of the deeply nested objects would cause a change in the value of the deeply nested object of the other. For example:

let objectX = {
    name: 'Mary', 
    age: 40,
    gadgets: { 
        brand: ["apple", "sony"]
    }
};

let objectY = {...objectX};
objectY.name = "Bianca";
objectY.gadgets.brand[0] = "hp";
console.log(objectX);
/*
{
    "name": "Mary",
    "age": 40,
    "gadgets": {
        "brand": [
            "hp",
            "sony"
        ]
    }
}
*/ 

console.log(objectY);
/*
{
    "name": "Bianca",
    "age": 40,
    "gadgets": {
        "brand": [
            "hp",
            "sony"
        ]
    }
}
*/

The above sample code performed the following actions:

1. Created an object named objectX.

2. Gave three properties to objectX: name, age and gadgets.

3. Gave the gadgets property of objectX an object as its value.

4. Gave the object value of the gadget property a brand property.

5. Gave the brand property an array as its value.

6. Copied the properties in objectX into objectY with the use of the spread operator.

7. Changed the value of the name property of objectY to Mary.

8. Changed the the first item in the array value of the brand property from apple to hp.

In the sample code, the array value is a deeply nested object. Notice that a change in the value of the name property of objectY did not cause a change in the value of the name property of objectX. But a change in the deeply nested object of objectY caused a similar change in the deeply nested object of objectX .

How to Iterate Over Objects in JavaScript

Use a for...in loop to iterate over an object and to select its properties. The for..in loop syntax is as follows:

for(let key in object) {
    //perform action(s) for each key
}

The key keyword in the syntax above is a parameter for the properties. So you can replace it with any word of your choice. Replace the object keyword with the name of the object you want to iterate over. For example:

let objectZ = {
    name: "Ade",
    Pronuon: "he",
    age: 60
};
for(let property in objectZ) {
    console.log(`${property}: ${objectZ[property]}`)
}
/* 
name: Ade
Pronuon: he
age: 60
*/

Notice the use of bracket notation in the loop to get the values of the property. Using dot notation instead of bracket notation would return undefined.

Conclusion

In JavaScript, objects are probably the most important data type. Programming concepts like Object-Oriented programming work on the principle of leveraging the flexibility of objects to store complex values and their distinct capability of interacting with properties and methods within the object.

This article lays a solid foundation for understanding such advanced concepts by explaining the basics of objects.

With programming, the greatest challenge is often not the complexity of the language, but rather staying consistent and motivated through the learning process.

In order to stay consistent with your learning, you will need a lot of motivation and energy. The consistency with which you learn would help you to understand the complex concepts of any programming language and make the most of your time.

Having come from an absolutely non-technical background, I had to learn this late. After I took the first step into the transition, I struggled with everything relating to learning, particularly motivation.

This article will share the steps I have gathered over time to overcome my struggles with staying consistent and motivated.

Start Slowly but Maintain a Habit

In the early stage of learning, you might only have a few free hours that you can dedicate to learning.

This is because most people are just opening themselves up to doing something they have never done before. Also, they might have tasks such as a full-time job which take a better part of their daily life. Therefore, adjusting and making time for learning might not be easy.

At this stage, you don't need to be concerned about the amount of time you have available to learn in one sitting. The most important thing is making time for a daily study session, regardless of its length, and persisting with it in spite whatever crops up in the way.

Always Schedule Your Tasks

If you don't schedule your daily tasks, it's much easier to procrastinate and forget about them. It's easy to become engrossed in just one or few tasks and lose sight of the fact that there are other things you need to do. Often, this happens when you don't follow a set task list.

To prevent procrastination and forgetfulness, make sure you plan out your days by scheduling tasks. You can use the following tips as a guide in scheduling your tasks:

1. Think of all the tasks you would like to accomplish.

2. Estimate how long it will take to accomplish each task.

3. Identify your peak hours of productivity.

4. Arrange the tasks in order of priority.

5. Make sure to bundle similar tasks together to improve your productivity.

6. To stay organized, schedule these tasks on your phone or computer and use reminder and task applications.

7. Schedule complex or difficult tasks during your peak productivity hours.

8. Make time for unexpected events in your schedule and plan for them ahead of time.

Note that it is a good idea to schedule your tasks at the beginning of every week.

To learn more about how you can schedule your day for better productivity, consider reading this article by John Rampton, the co-founder and CEO of Calendar.

Join a Community of Learners

For most people, learning alone can be boring and tedious, and in no time, it can hurt your motivation. This is why having a community of like-minded people is always better.

This type of community will provide you numerous benefits, including, but not limited to:

• access to group study

• access to different resources to help with your study

• information on current technological trends

• getting feedback on personal projects

• an avenue to share your progress and measure your growth

Find out if this type of community exists in your area. Alternatively, if you are unable to find one, you can join a remote learning community instead.

The following are some of the remote communities I have personally found useful and consider to be of great value:

• 100Devs: The 100devs community is a nonprofit organization founded and maintained by Leon Noel, a teacher and Managing Director of Engineering at ResilientCoders. The 100Devs community provides free lessons in full-stack web development to individuals. You can join the 100Devs community here.

• 100DaysofCode: 100DaysofCode is an online challenge where people dedicate 100 days to learning a programming language of their choice. In order to participate in 100DaysofCode, you must devote at least an hour a day to learning. And after that, you post a completed task on Twitter with the hashtag #100DaysofCode.

• Kevin Powell Community: The Kevin Powell Community of active learners is a community on discord created and maintained by Kevin Powell. Kevin is a teacher and software developer with years of experience. You can join the Kevin Powell Community on discord.

• Commit Your Code: The Commit Your Code community is created and maintained by Danny Thompson. The community has a lot of active learners as well as experienced developers who are more than willing to help you with your projects and mentorship. You can join the Commit Your Code community on discord.

And of course the freeCodeCamp community has a supportive and friendly forum where you can ask questions and meet other developers.

After joining one or more of these communities, it is important to be on your best behaviour. Keep in mind to also be kind, provide value, and follow their rules.

Find a Study Partner

Being consistent and motivated may be hard even after scheduling your tasks and joining a study community. If this is the case, you might need a study partner.

You can benefit from having a study partner in the following ways:

• Makes sure you have accountability.

• You can set up joint study sessions.

• You can collaborate on joint projects.

• You might find mentorship.

• You can go through coding challenges together.

Use an Efficient Study Technique

Programming languages are generally complex. Unless you have an effective study technique, it will be difficult to understand the concepts and apply them in practical contexts. This can make you frustrated and lessen your motivation to learn.

If you're learning new concepts or a new programming language, here are some study techniques you might have tried:

• repetitive reading, otherwise known as re-reading

• highlighting

• summarizing or making notes

• cramming

But there's lots of evidence from prominent scientists and psychologists that has proven that these techniques are less effective when compared to other study techniques you can use.

To make the best use of your time and ensure you remember what you have studied for a longer time, try the following study techniques:

Active Recall

Active recall is a study technique that involves retrieving already stored information from your brain.

The mind is a vast storehouse or space; memories are objects stored in that space; and retrieving a memory is akin to searching for and finding an object in a physical space (Roediger, 1980).

Using this technique involves reading a topic once and then converting concepts and ideas in the topic you have read into questions and then testing yourself on them.

Spaced Repetition

This study technique, as its name suggests, involves spacing revisions of what you have learned by way of active recalling. This is in contrast to cramming, which involves memorizing all the concepts in a particular topic in a single sitting.

Essentially, spaced repetition helps you minimize the effect of The Forgetting Curve. It is a mode of learning by which you allow yourself to forget what you have learned. Then you try to retrieve those concepts from your brain by making active recalls at specific intervals over a period of time.

The forgetting curve hypothesizes the decline of memory retention in time. This curve shows how information is lost over time when there is no attempt to retain it. (Source)

Using the above study techniques will help you make sure that you are not spending too much time understanding and remembering any topic or concepts.

In addition, you will have more time to complete other tasks on your list, as well as the opportunity to learn new skills that will be helpful in your professional development.

One popular tool you can use to help with active recall and spaced repetition is Anki. Learn how to use Anki here.

To learn more about the use of these efficient study techniques, watch the video below:

Pomodoro timer

The Pomodoro study technique is ideal for people who struggle to concentrate on studying for a lengthy period of time.

One way to use this technique is to break your workday into 30 or 20 minute chunks separated by five minute breaks. These intervals are called Pomodoros.

Set Short Term Goals and Stay Focused on Achieving One Goal at a Time

Success doesn't happen overnight.

Trying to achieve too many objectives at the same time can be overwhelming. So it's always better to break your objective into shorter chunks of goals and focus on accomplishing one of the chunks or goals at a time.

For instance, let's say your goal is to be able to build a webpage with any of the popular JavaScript framework as a beginner. To do that, you'll need to learn various scripting and programming languages, tools, and skills. Here's what you should know to build a webpage:

1. Understand the basics of HTML.

2. Understand the basics of CSS.

3. Understand the use of semantic elements in HTML.

4. Understand the use of CSS Flexbox and Grid for layouts.

5. Try building a simple static website with what you have learned so far.

6. Start learning the basics of JavaScript.

7. Focus on building projects with your knowledge of HTML, CSS and the basics of JavaScript you have learned so far.

8. Start learning advanced JavaScript concepts such as Objective Oriented Programming, and Asynchronous Programming.

9. Solidify you knowledge on the advanced concepts by building projects with them.

10. Learn the JavaScript framework of your choice. React, Vue, and Angular are all popular choices.

11. Finally you can build your favourite project using the framework you have learned.

You might think that going through the steps above in the order they are stated would take you a few months. But it may take you much longer than that – and that's ok.

Also, don't try to skip any of these steps. Simply taking a crash web dev course likely won't be enough, and can set you up for disappointment and cause you to struggle much more than you would if you'd taken your time learning the concepts thoroughly.

On the other hand, making sure that you carefully go through each of the steps, one at a time, will help you to build the skills necessary to achieve your main goal. It will also prevent you from losing motivation, which is the likely result of having unrealistic expectations.

Don't be Afraid to Ask for Help

One of the reasons why people give up early when learning programming is because they encounter some sort of bug in their program that seems difficult to solve.

But you should know that no one knows it all when it comes to programming. Even software developers with decades of experience still encounter bugs they find very hard to solve on their own.

This is a major reason why collaboration is so important – even more so than developing your personal skills.

Whenever you find yourself in this situation, do not linger on the problem for too long. Use the internet to your advantage when searching for answers. In this regard, your best friend is Google. You can get the answer to almost everything related to programming on Google if you take your time and search deeply.

If you are unable to get the answer you need from searching on Google, then the next step to take is to go to the study community you belong to get help from others. They will typically be more than willing to help you, whatever the problem may be.

Take note of the following when seeking help from your community:

• Make sure to ask direct questions.

• Make sure your questions are clear enough to understand.

• Provide a copy of your code by putting them in a public remote repository such as GitHub or Codepen and provide the link to the repository.

Maintain a Healthy Lifestyle

I can't overemphasize the benefits of maintaining a healthy lifestyle. It will help your maintain energy and keep you fit for the next challenge.

There are several ways to maintain a healthy lifestyle, some of which are:

• Get regular exercise to help your cognitive abilities and general fitness.

• Don't sit for lengthy periods of time.

• Exercise your fingers regularly while you're studying.

• Keep your eyes off your screen at regular intervals while you study.

• Make time for your hobbies as a reward for your efforts.

• Ensure you always sleep well and get a proper amount of rest.

Conclusion

Programming is a marathon, not a sprint. If you want to achieve any level of success, you have to take your time and study consistently.

Taking the steps discussed in this article will significantly improve your chances of reaching your goals.

If you enjoy this article, then you should give me a shout-out.

Further Reading and References

1. Retrieval creates learning.

2. The forgetting curve.

3. Download Anki, a powerful tool for active recall and spaced repetition.

This modification in an HTML document, for instance, usually takes the form of creating, adding, or removing elements in the document.

In this article, you'll learn what the Document Object Model (DOM) is, a bit about its history, and how you use it to manipulate web documents, especially HTML documents.

What is the Document Object Model (DOM)?

The DOM is a web interface, developed and released by the World Wide Web Consortium (W3C). This organization was founded to establish standards for the World Wide Web.

The DOM is a web API that is language-neutral. This means that you can implement and adopt it in any programming language.

The DOM represents the structural pieces of a web document as objects that can be accessed and manipulated. In other words, the DOM allows you as a software developer to do the following:

• Create and build web documents.

• Navigate the structure of web documents.

• Add, modify, or delete elements and content within web documents.

History of the DOM

The history of the DOM is relative to JavaScript and JScript as the first widely used scripting languages. These languages helped make web pages interactive.

Prior to the development of a standard DOM specification by the W3C, JavaScript and JScript had different ways of enabling access to manipulating HTML documents.

These limited methods and interfaces that let you manipulate HTML documents in this way became the DOM Level 0.

In 1998, the W3C completed its draft of the first standard DOM specification, which became the recommended standard for all browsers. This standard DOM specification became DOM Level 1. The DOM level 1 provided a comprehensive model for manipulating both HTML and XML documents.

In 2000, the W3C released DOM Level 2, which introduced methods such as getElementById(), as well as a standardized event model and support for XML namespaces and CSS.

The DOM Level 3, released in 2004, added support for XPath and keyboard event handling. And in late 2015, the latest DOM specification, DOM Level 4, became a published standard.

What is the DOM Tree?

The structural representation created by the DOM is very much like a tree. It has several objects in it known as nodes.

The browser uses the DOM tree representation it builds from an HTML document to determine what to render on a web page. For example, a visual representation of a DOM tree will look like this:

The DOM Tree

The HTML document of the above DOM tree looks like this:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>TITLE</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
    <div>
        <h1>HELLO WORLD</h1>
    </div>
    <a href="link text">Document Object Model</a>
</body>
</html>

Nodes vs Elements in the DOM

Often, developers confuse nodes with elements. So we should distinguish between the two early in this article to avoid confusion.

Nodes are all the components a web page document is made up of. In other words, a web page is collection of nodes.

An element is a type of node within a document. For instance, the DOM property nodes.childNodes when used on a parent node will return all the different nodes contained within that specified parent node.

In the example below, the childNodes property is used on the <body> element node of the HTML document given above:

//javascript content

//select the <body> element node with the DOM method querySelector
const body = document.querySelector('body') 
//select the children nodes with the <body> element node with the DOM property node.childNodes
const childrenNodes = body.childNodes
//console log the children nodes
console.log(childrenNodes)//NodeList(5) [text, div, text, a, text]

Notice that there are five items in the nodeList. This is because we have another type of node, the text nodes, different from the element nodes within the <body> element node.

To investigate this further, go through the following steps in your console:

1. Click on the dropdown icon just before "nodeList".

2. Select the text node by clicking on the dropdown icon before "test".

3. Check for the textContent option within the list options in the dropdown.

If you follow the above instructions, you will see that the test content of the first text node is "/n ". This is a text node indicating a new line after the <body> element node, the <div> element node, and the <a> element node.

Relationships Between Nodes in the DOM Tree

The nodes in the DOM tree have a hierarchical relationship with each other in the DOM tree. They are defined by their position relative to each other in the DOM tree.

These are the node positions present in the DOM tree illustration above:

• Root node: The root node is always at the apex of the DOM tree. In an HTML document, the root node is always the <html> element.

• Child node: A child node is a node embedded inside another node. In the illustration given above, the <head> and the <body> elements are the children of the <html> element.

• Descendant node: Any node positioned below another node in the hierarchical order is the descendant of the nodes positioned above it. For example, although the <h1> element is not the direct child of the <body> element, it is a descendant of the <body> and root <html> elements.

• Parent node: Any node which has another node inside it is a parent node. For example, the <body> element is the parent of the <div> and <a> elements in the above example. Note that only element type nodes can be a parent node.

• Sibling nodes: Nodes that are on the same level in hierarchical order in the DOM tree are sibling nodes. For example, <div> and <a> elements in the above example are siblings.

• Leaf nodes: The text inside of elements are leaf nodes. This is because they cannot have children nodes of their own.

HTMLCollection vs nodeList

To manipulate the DOM tree, you need a way to select individual items or a collection of items in it.

You can use a programming language like JavaScript to select an item or a collection of items in the DOM tree by using a few methods provided by the DOM.

The methods getElementById() and querySelector() can select individual items. The methods getElementsByClassName(), getElementsByTagName(), or querySelectorAll() can select a collection of items.

In the DOM tree, we can either get an HTMLCollection or a NodeList based on the method used to select a collection of items. The getElementsByClassName() and getElementsByTagName() methods return HTMLCollections, while querySelectorAll returns a nodeList.

HTMLCollection and nodeList share some similarities and differences. They're similar in the following ways:

• They are array-like objects.

• They are collections of items.

• They can be converted into an array by using the Array.from() method.

• They both have a zero-based indexing.

• They can both be iterated over with a for...loop.

• They have a length property.

• They do not have array methods available to them.

Below is a sample HTML document and JavaScript code to emphasize these similarities:

<!-- html documant -->

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
   <ul>
    <li>item one</li>
    <li>item two</li>
    <li>item three</li>
    <li>item four</li>
   </ul>

    <script src="main.js"></script>
</body>
</html>

//javascript content

const listItemsHtmlCollection = document.getElementsByTagName("li")
console.log(listItemsHtmlCollection) // HTMLCollection(4) [li, li, li, li]

const listItemsNodeList = document.querySelectorAll("li")
console.log(listItemsNodeList) // NodeList(4) [li, li, li, li]

You can see from the above that while the getElementsByTagName returns an HTMLCollection with items matching the <li> tag specified, the querySelectorAll returns a nodeList.

Now, let's use a for...loop to iterate on both collections:

for(let i = 0; i < listItemsHtmlCollection.length; i++) {
    listItemsHtmlCollection[i].style.color = 'red'
}

for(let i = 0; i < listItemsHtmlCollection.length; i++) {
    listItemsHtmlCollection[i].style.color = 'red'
}

In both instances the color of the text will be changed to red.

Now let's delete the for...loop iteration and use an array method on map to iterate over both collections:

listItemsHtmlCollection.map( element => element.style.color = 'red' )
listItemsNodeList.map( element => element.style.color = 'red' )

To use the map array method successfully, you have to convert both items to an array with the Array.from() method like this:

Array.from(listItemsHtmlCollection).map( element => element.style.color = 'red' )
Array.from(listItemsNodeList).map( element => element.style.color = 'red' )

There are two major ways in which HTMLCollection and a nodeList differ from one another. They are:

• A nodeList comes with some inbuilt methods and properties not available in an HTMLCollection. The methods include the forEach() and the entries methods to iterate over a nodeList. The properties include the keys property and the value property.

• An HTMLCollection is always live, while a nodeList can either be live or static. A collection of nodes is live if a change in the DOM tree updates the collection automatically. If a change in the DOM tree does not affect the collection, then it is static. DOM changes can be the addition of a new node or the removal of an existing node. DOM methods such as getElementById() and getElementsByClassName() return HTMLCollections, which is always live. The querySelectorAll() method returns a static nodeList.

DOM HTML Methods

The DOM level 1 core, Dom level 2 core, and Dom level 3 core introduced several methods that allow web developers to manipulate the DOM tree. Some of these methods are the following:

The createElement() DOM method

The createElement() method creates an element of the type specified as its argument.

//html document

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
   <ul>
    <li>item one</li>
    <li>item two</li>
    <li>item three</li>
    <li>item four</li>
   </ul>

    <script src="main.js"></script>
</body>
</html>

//javascript content

//select the parent element
const list = document.querySelector('ul')
//create a new element
const listItem = document.createElement('li')
//make the newly created element a child of the parent
list.appendChild('listItem')
console.log(list)

Now check the console for the list console logged. You'll see that there are five <li> elements now within the <ul> parent element.

The createTextNode() DOM method

The createTextNode() method creates a text node with the string specified as its argument. Let's add text to the <li> element we created above.

//javascript content

const listText = document.createTextNode("item five")
listItem.appendChild(listText)

Now save your JavaScript file and reload your webpage.

The appendChild() DOM method

The appendChild() method adds a node to the end of the list of children of a parent node.

If the specified child is an existing node in the document, appendChild() moves it from its current position on the DOM tree to the new position. We used the method earlier to make our newly created <li> element a child of the <ul> element.

The getElementById() DOM method

This method selects and returns the element whose ID is specified within it as a argument. If no such element exists, the method returns null. Let's add an id attribute to our <ul> element in the HTML document and give it a red border.

//html document

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
   <ul id="ulList">
    <li>item one</li>
    <li>item two</li>
    <li>item three</li>
    <li>item four</li>
   </ul>


    <script src="main.js"></script>
</body>
</html>

//javascript content

const ulList = document.getElementById("ulList") 
ulList.style.border = '2px solid red'

The getElementsByClassName() DOM method

The getElementsByClassName() method selects all elements with the specified class name and returns them as an HTMLCollection in the order they appear on the DOM tree.

You can access individual elements in the HTMLCollection by their index number. Let's add a class attribute to the first two <li> elements in our HTML document and change their text color to red like this:

//html document

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
   <ul id="ulList">
    <li class="itemOneAndTwo">item one</li>
    <li class="itemOneAndTwo">item two</li>
    <li>item three</li>
    <li>item four</li>
   </ul>


    <script src="main.js"></script>
</body>
</html>

//javascript content

//select by elements one and two by their class name
const itemOneAndTwo = document.getElementsByClassName("itemOneAndTwo")
//change text color to red with use of index
itemOneAndTwo[0].style.color = 'red'
itemOneAndTwo[1].style.color = 'red'

The getElementsByTagName() DOM method

The getElementsByTagName() method returns an HTMLCollection of all the elements with the tag name specified as its argument, in the order they appear on the DOM tree.

Let's select the <li> elements with the getElementsBytagName() method and change their font style to italic.

//javascript content

const liTags = document.getElementsByTagName("li") 
for(let i = 0; i < liTags.length; i++) {
    liTags[i].style.fontStyle = 'italic'
}

The querySelector() DOM method

The querySelector() method accepts any CSS string selector as an argument. It then uses the specified selector to select the first within the document that matches that specified selector.

Let's change select our first two <li> elements with the querySelector() method and change their text color back to black.

//javascript content

const querySelectItem = document.querySelector("itemOneAndTwo")
querySelectItem.style.color = 'black'

Notice that only the first list item has had its color changed to black.

The querySelectorAll() DOM method

The querySelectorAll() method, just like the querySelector method, accepts any CSS string selector as its argument. It then uses the specified CSS string selector to select all elements that match that specified selector, put them in a nodeList, and return that nodeList.

Now, let's use it to change all the text in out list items to green.

//javascript content

const querySelectAllItems = document.querySelectorAll("li")
for(let i = 0; i < querySelectAllItems.length; i++) {
    querySelectAllItems[i].style.color = 'green'
}

The setAttribute() DOM method

The setAttribute() method adds a new attribute name to an element. If an attribute with that name is already present in the element, its value will change to that of the value set in the argument.

The method accepts two arguments. The first argument is the name of the attribute you want to create. The second argument is the value to set on the attribute, which is always a string.

Let's use it to give our third item a class attribute and change the text color to black.

//javascript content

const itemThree = querySelectAllItems[2] 
itemThree.setAttribute("class", "attributeValue")  
const attributeValue = document.querySelector('.attributeValue')
attributeValue.style.color = 'black'

The removeAttribute() DOM method

The removeAttribute() method removes a specified attribute. It takes in the name of the attribute to be removed as its argument. Let's remove the id attribute from the <ul> parent element and use the removed id to removed its red border.

//javascript content

//remove attribute
ul.removeAttribute('id')
ul.style.border = 'none'

Now save your JavaScript file and reload your web page. Notice that the borders are still there. If you check the console you will see an error message stating that ul is no longer defined.

The contains() DOM method

The contains() method returns true if a node is a descendant of a node and returns false otherwise.

<--HTML document--> 
<body>   
    <h1>Heading</h1> 
</body>

//javascript content
const body = document.querySelector('body')
const h1Element = document.querySelector('h1')
console.log( body.contains(h1Element) ) // true

The item() DOM method

The item() method returns the item specified at the index specified as its argument when used on a collection.

<--HTML document--> 
<body>   
    <p>Paragraph</p> 
    <p>Paragraph</p> 
</body>

//javascript content
const pElements = document.querySelectorAll("p") 
console.log(pElements.item(0)) // <p></p>

The hasChildNodes() DOM method

The hasChildNodes method returns true if the element it is called on has child nodes within it and returns false otherwise.

<--HTML document--> 
<body>   
    <p>Paragraph</p> 
    <p>Paragraph</p> 
</body>

//javascript content

const body = document.querySelector("body")

console.log(body.hasChildNodes()) // true

What are DOM Events?

To make our web page logically interactive by initiating automatic responses or incidents on the web page, we need Events.

DOM events are:

actions or occurrences that happen in the system you are programming, which the system tells you about so your code can react to them. (Source: MDN)

A common example of an event is when a user clicks a submit button in a form, which then submits the data input by the user as a response to the click.

Another example is when a user clicks on a menu icon, which then triggers a drop-down navigation or options.

You can use scripting languages such as JavaScript to register event handlers or listeners on elements inside the DOM tree, which runs when the specified event fires.

An event handler is a:

block of code (usually a JavaScript function that you as a programmer create) that runs when the event fires. When such a block of code is defined to run in response to an event, we say we are registering an event handler. (Source: MDN)

Examples of events used on elements in the DOM tree include:

• click: A click event is a mousedown or mouseup over an element on a webpage.

• keypress: A keypress event occurs when keys on the keyboard are pressed.

• mouseover: A mouseover event occurs when the pointing device is moved onto an element.

• dblclick: A dblclick occurs when there is a double-click event over an element on a webpage.

• submit: A submit event occurs when a form is submitted.

Conclusion

The DOM is the backbone of modern web dynamism. It represents every piece of a web document as an object and provides programming languages with the necessary methods to manipulate and modify each piece.

If you enjoyed this write-up, you should give me a shoutout.

References and Further Reading

1. https://dom.spec.whatwg.org/

2. https://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core.html

3. https://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html.html

4. https://www.w3.org/TR/DOM-Level-2-HTML/

5. https://www.w3.org/TR/DOM-Level-3-Core/core.html