How to automate simple tasks using scripts?

Every programmer’s daily work involves numerous routine tasks that waste time. This time could be used for more interesting and/or important tasks: writing or refining code, developing design specifications, or conducting reviews. To avoid wasting time on routine tasks, scripts come to the rescue—they automate the execution of repetitive, repetitive tasks.

Moreover, scripts not only save time but also reduce the likelihood of errors. They can help with regular file copying, data collection, or scheduled system backups. Overall, they will be useful for both beginners and experienced IT professionals.

In this article, we’ll discuss which language to choose for writing scripts, provide examples of simple automation scripts, and outline a list of steps for creating effective scripts.

Choosing a language for writing scripts

Choosing the right scripting language depends on the specific tasks, the programmer’s environment, and their skill level. Below, we’ll look at the three main programming languages ​​for scripting.

Overview of popular languages

Bash

The standard command-line interpreter on UNIX systems. Bash is good for automating tasks at the operating system level: file management, automated cron jobs, and so on. Bash is especially suitable for system administrators and anyone using Linux or UNIX.

Python

One of the most versatile languages, Python stands out for its simplicity and extensive library base. It’s suitable for both beginners and those experienced in data processing or web scraping. Python is supported by virtually all platforms and can handle more complex and extensive tasks with the help of a wide range of extensions.

PowerShell

A well-known Microsoft product, it’s great for SCM and automation of Windows-based system tasks. PowerShell has one major advantage: integration with all available Microsoft services (including Active Directory). It’s suitable for enterprise projects on Windows.

Recommendations for beginners

If you’re just starting to think about how to automate routine tasks with scripts, or are just beginning to delve into the topic, we have 5 key tips:

• Choose a simple task or script that you regularly perform manually. This could be sending emails, adding tasks to trackers, checking code and configurations—basically, anything. 
• Learn the basics of the language you choose to write scripts in to better understand the additional features available for automating system tasks;
• Practice is the best way to learn programming , so don’t be afraid to experiment with the code (just make sure to always make a backup :).
• Check out developer forums —there you can not only find answers to your questions but also learn about other programmers’ experiences. Maybe you’ll find a new and interesting solution?
• Always write comments on your code —this will help you understand it better yourself, and then you can share both the code and the comments with other developers who might suggest, for example, shortening the code with a simpler command.

Simple examples of automation

Copying and Organizing Files with Bash

As we’ve already mentioned, Bash is often chosen for writing scripts on Unix or Linux.

Example: You have a folder with different file types. You need to sort them into different directories by type.

Script for automation:

Step one: launch Bash:

#!/bin/bash

Step two: create directories for each file type:

mkdir -p Documents Images Videos Others

Step three – moving files:

for file in *; do
    if [[ -f $file ]]; then
        case $(file --mime-type -b "$file") in
            text/*) mv "$file" Documents/ ;;
            image/*) mv "$file" Images/ ;;
            video/*) mv "$file" Videos/ ;;
            *) mv "$file" Others/ ;;
        esac
    fi
done

This script checks the MIME type of each file and moves it to the appropriate folder. No manual action is required—just run the script.

Automating Web Data Collection with Python

Example: Let’s say you want to get the latest articles from a website on a regular basis.

Script for automation:

Step one: run the BeautifulSoup library:

import requests
from bs4 import BeautifulSoup

Step two: specify the desired URL and write the request:

URL = 'https://tproger.ru/'
response = requests.get(URL)
soup = BeautifulSoup(response.content, 'html.parser')

Step three: parse articles from the page:

articles = soup.find_all('article')
for article in articles:
    title = article.find('h2').get_text()
    summary = article.find('p').get_text()
    print(f'Название: {title}\nОписание: {summary}\n')

This script sends a GET request to a website and extracts article titles and summaries. This means you can use this script to retrieve information about the latest articles (in title and summary format) from any website.

Setting up regular tasks via cron or Task Scheduler

The scripts are created and everything works correctly. Then it’s time to automate the scripts using task schedulers. On Unix systems, this can be done using cron, and on Windows, using Task Scheduler.

Example of cron setup:

Open the crontab file with the crontab -e command and add the line:

0 6 * * * /path/to/your/script.sh

So the script will be executed every morning at 6 am.

Example of setting up Task Scheduler:

• Open Task Scheduler;
• Select “Create Task”;
• Set the task execution trigger to “on schedule”;
• Specify the program or script to execute (for example, the path to a Python script).

By setting up schedulers, you can automate any task. Get the latest articles from Tproger every Monday at 9 AM? No problem. Check system configurations every day after making any code changes? Yes, please! A well-written script can help with everything.

Key steps in writing scripts

The most important step when writing any script is a thorough understanding of the task you want to automate. Without this understanding, there’s a high risk of creating an ineffective or incorrect solution.

What’s important here:

• Define the ultimate goal of automation;
• Collect all necessary data;
• Understand what processes or steps need to be completed.

For example, if you want to automate weekly reporting through scripts, you need to define the data sources, the format of the resulting data, and the frequency of script execution.

The next step is to develop an algorithm, a step-by-step plan of action for regularly and correctly executing the script. Here, it’s crucial to break the task down into smaller, more manageable parts: first, you add the resource from which the articles will be pulled; then, you select what exactly will be sent to you as the final result (article titles and summaries); and then, you specify the format in which you want the result.

Preparing an algorithm is:

• Precise specification of input data;
• Development of script logic;
• Specifying the order of actions within a script.

Try creating a flowchart for clarity if you’re faced with a complex automation task. Detail which inputs need to be processed, in what format, whether they need to be converted, what to do with them, and the output format. This will help you better understand the script’s logic and avoid potential errors.

Important: Only a very simple script will work perfectly the first time. That’s why scripts should always be tested and tweaked on the fly. This way, you can ensure their effectiveness.

Script testing consists of 3 main steps:

• Running the script with different sets of data to check the correctness of execution;
• Finding and correcting logical errors or incorrectly written assumptions in the algorithm;
• Bug fixes and code optimization.

Pay special attention to unusual or rare stories to ensure that your script always runs without errors after debugging.

Tools for development automation

Command line utilities

find — a tool for searching files within a directory structure. It helps you find files by name, size, modification date, and other parameters. For example, you can use find to search for all files with the .txt extension that were modified in the last 7 days:

find /path/to/directory -name "*.txt" -mtime -7

grep— a tool for searching text strings in files using regular expressions. It can help you filter data or find specific information in large logs:

grep "ошибка" /var/log/syslog

awk— a programming language for processing text data. Suitable for analyzing and transforming text and data from tables:

awk '{sum += $1} END {print sum}' file.txt

Libraries and modules for Python

The Python module os helps manipulate files and directories, facilitates process management, and so on:

import os
os.mkdir('новый_каталог')

shutil— a module for performing operations with files: copying, moving, archiving:

import shutil
shutil.copy('исходный_файл.txt', 'копия.txt')

This module schedulewill help you schedule Python tasks. Automation script:

import schedule
def job():
    print("Работа выполняется")
schedule.every().day.at("10:30").do(job)
while True:
    schedule.run_pending()
    time.sleep(1)

Task schedulers

cron— a system task scheduler for UNIX systems that helps automate the execution of scripts or commands on a schedule:

Launch script.shevery day at 3am:

0 3 * * * /path/to/script.sh

The command atis needed for one-time execution of tasks at a specific time. Suitable for irregular tasks:

echo "python my_script.py" | at 14:00

Tips for Improving Script Development

To create truly great, accurate, and error-free scripts, you need to adhere to three basic rules: logging to understand the script execution status and find bugs, using modules and extensions to check for errors, and documenting your code through README files for future reference.

Use logging

Logging is essential for any type of code. It helps you understand the current state of your script’s execution and helps you identify problems. There are three main benefits of logging:

• Logs help you understand which parts of your code are running and which aren’t—a useful feature when working with complex processes and tasks.
• Logs may also contain information about errors and exceptions.
• Logs allow you to track the actual execution time of different parts of a script, making it easier to analyze performance.

To implement logging, you can use built-in libraries of programming languages: logging in Python or logger in Bash.

Add error checking

No code is error-proof, so it’s important to think about bugs in advance and develop a way to “catch” and debug them . This will not only make the script more stable and “trained” on bugs, but will also protect data from corruption.

• Please make sure all input data is filled in correctly before testing the script for the first time.
• Use try-except in Python or similar blocks in other languages ​​to catch and properly handle errors.
• Return error codes to better understand the nature of the problem for both you and the end user.

Document code for reuse

Documenting your code isn’t just a “goodwill gesture” so other programmers can learn from your code; it’s crucial for reusing your script in the future:

• Describe the purpose of functions and key code blocks so that you (and other users) can more easily understand the structure of your script in the future.
• Write separate README files to describe in detail how the script works.
• Don’t neglect coding standards; actively use them. This will make your code easier to read and understand for others.

Conclusion

Using scripts significantly reduces the number of routine tasks, improves their accuracy, and saves significant time in the long run. Scripts automate virtually any development process. While they’re running, you can focus on more interesting and important tasks. But remember: automated, perfectly functioning, and adaptive code isn’t the work of a “machine,” but the work of the developer who wrote the scripts. This means you should always invest in refining and improving the code, finding and fixing bugs, and adding new functions and variables.