DEV Community: Hyperskill

Why Frontend Development is a Great Way to Start Programming in 2024/2025

nastuxacool — Thu, 14 Nov 2024 06:11:26 +0000

As technology continues to grow, front-end development has become one of the easiest ways to start learning programming. Whether you’re new to coding or thinking about a career change, front-end development offers a highly visual and rewarding entry point with many possible career paths. Here’s why starting with front-end development could be your perfect choice.

1. Instant Visual Results Make Learning Fun

One of the best parts of front-end development is seeing your results right away. As you code, you see your work appear on a webpage instantly, which makes learning more engaging and satisfying. Unlike back-end development, where much of the work happens behind the scenes, front-end development lets you create the parts of a website that users actually see and interact with. This instant feedback helps you learn quickly, make changes as you go, and feel a sense of accomplishment as you build real web interfaces.
Take a look what the combination of HTML, CSS and JavaScript has to offer
https://hyperskill.org/projects/230/stages/2415/implement

2. High Demand for JavaScript Skills Across Many Jobs

Front-end development uses HTML, CSS, and especially JavaScript—a language that powers interactivity on the web and is highly valued in the tech industry. Learning JavaScript can open doors to many roles, from web and mobile app development to jobs in other tech fields. JavaScript is one of the most popular programming languages worldwide, so learning it gives you a foundation that will stay relevant for a long time.

3. A Foundation for Diverse Career Paths

Front-end development doesn’t limit you to just one type of job—it gives you a strong base to build many different skills. As you learn HTML, CSS, and JavaScript, you can start exploring other areas like back-end development, mobile app development, or even game creation. You can even use JavaScript with tools like Node.js and Express to learn back-end programming, making it easier to become a full-stack developer if you choose. With tools like Ionic and React Native, developers can create apps that work on iOS, Android, and desktops—all without having to rewrite code for each platform. Learning front-end skills gives you the freedom to try many paths in the tech world.
If you still don’t believe us, see for yourself: here’s a recent job offer by Telegram: Javascript + SQL Developer. No React, no Figma, just JS and databases! https://jobs.ton.org/companies/wallet-2/jobs/40637883-sql-javascript-developer#content

4. Access to a Helpful and Active Community

Front-end development has one of the most welcoming and helpful communities in tech. From online forums and coding events (e.g. CSS Days) to documentation, there is a lot of support available to help you learn. Tutorials, open-source libraries, and websites dedicated to front-end development make it easier for beginners to find solutions to common problems. If you like blogs, you can always read “Overreacted” by Dan Abramov (https://overreacted.io/). You prefer to listen rather than to read? No worries, Google team got you covered: here’s a CSS podcast: https://thecsspodcast.libsyn.com/
This active community provides guidance and encouragement as you grow.

5. Work Flexibly and Remotely

If flexibility and remote work are important to you, front-end development is a great choice. Many front-end and full-stack jobs are remote-friendly, and tech companies, startups, and freelance work all often welcome front-end developers who work from home. This flexibility lets you work from anywhere, whether in a home office or while traveling as a digital nomad. Front-end skills are very adaptable, so you can build a career that fits your lifestyle.

6. A Mix of Creativity and Problem-Solving

Front-end development is ideal if you enjoy combining creativity with logical problem-solving. In this field, you can design visually appealing websites while making sure they work well for users. Front-end development taps into both artistic and technical abilities, letting you create and innovate in the digital space.
Just take a look at the stunning creations of Julia Miocene: https://codepen.io/miocene

7. Tasks for Every Skill Level

Front-end development includes tasks for everyone, from beginners to experts. Beginners might start by creating basic user interfaces or simple web pages, while experienced developers can work on complex projects like improving website performance. This range of tasks allows you to find projects at your skill level while leaving room to grow. The field values contributions at all levels, so you can continue advancing within front-end development.

8. A Fast-Changing Field with New Trends

Front-end development is a dynamic field with new tools, libraries, and trends appearing frequently. This keeps the work interesting but also means that staying up to date is important. Recent trends include new frameworks (like SolidJS or Svelte), CSS improvements for design, and better tools for faster websites. A solid base in front-end development makes it easier to keep up with these changes. With resources like Hyperskill, you can stay on top of new trends and make learning part of your regular routine.

Common Beginner Challenges

While front-end development has many benefits, beginners should be ready for a few common challenges. For example, learning how to make websites look good on any screen size (called “responsive design”) can be tricky at first. Debugging JavaScript errors and handling differences between browsers are also skills that take time to learn.
Fortunately, the active front-end community and available resources make it easier to overcome these challenges and build confidence. One resource that we highly recommend is our 6-month mentor-led learning program! See for yourself: https://go.hyperskill.org/frontend-developer

Conclusion

Front-end development is an accessible and flexible way to start programming. With immediate visual feedback, high demand for skills, and many career options, it’s a great choice for anyone looking to enter tech. Whether you want to become a web developer or explore related fields, front-end skills give you a solid foundation with many possibilities. You can succeed in this fast-changing field with commitment, enjoying both the challenges and rewards. If you’re ready to start your journey in programming, front-end development could be your first step toward a fulfilling, flexible, and creative career.

Preparing for Your Technical Interview: A Developer's Guide

Victoria Lisitsyna — Thu, 11 May 2023 13:13:30 +0000

The interview is an important step to getting the job. The course of the interview determines whether they will be hired or not. It also defines the final salary and grade. Even if an interviewee knows a programming language well, an interview is always stressful, and it can be an obstacle to put one's best foot forward.

Considering that to get a good job, you need to prepare for your interview carefully. In this article, I want to share a few tips to help developers prepare for technical interviews, and tell how Hyperskill will be useful for this. These tips helped me to prepare and pass several developer interviews.

If you're looking for a way to learn new skills and advance your career, Hyperskill's project-based learning platform offers a personalized curriculum and a variety of tracks to help you achieve your goals.

Six tips for preparing for an interview

Tip 1: Get details about the upcoming interview

If you are interested in joining a particular company or team, you can get information before the interview about what to expect. For example:

google other people's feedback about the interview process and the questions they were asked.
find a few articles about the hiring process in this company.
look at the list of skills in the job description (in LinkedIn, for example). Most likely, the interviewer will ask you skill-related questions.

Tip 2: Structure your previous experience

Structure your previous work experience or pet projects. Recall difficult problems that you were able to solve. During the interview, you may be asked to talk about the projects where you have been involved, the challenges you have encountered, and the topics you have learned.

If you are preparing for your first interview and don't have any work experience, it is helpful to publish several training pet projects on GitHub. As a project-based educational platform, Hyperskill engages you in solving projects related to different domain areas so that you could publish the results. And what's more, some of the projects are based on real test assignments. For example, if you are a Java developer, pay attention to the following projects: Java Online chat, File Server, SQLite Viewer. And here are the Python projects based on real test assignments: Web Scraper, To-Do List, Regex Engine.

Tip 3: Find and answer the top interview questions

To prepare for a job interview, google the top questions on a programming language, a framework, or a tool you're interested in and find the answers.
For example, there is a list of top Python interview questions. You can easily find similar question lists for other languages.

Tip 4: Fill the knowledge gaps in your programming language and tools

Revise the programming language concepts. Focus on your gaps. Interviewers often ask questions to check your competencies and understand whether you are following trends in your domain.
Take note of the Hyperskill tracks. Hyperskill covers all popular programming languages and more. Tracks combine theory with practice, which helps you better understand and remember information.

Tip 5: Learn basic algorithms and data structures

Interviewers often ask questions about computer science fundamentals, basic algorithms, and structures. They include specifics on sorting and search algorithms, arrays, lists, stacks and queues, hash maps, trees, and others. Before the interview, it is worth reviewing these concepts and solving some exercises using them. You can repeat them by solving the Practicing Algorithms with Python track on Hyperskill.

Tip 6: Prepare for live coding exercises

If you are supposed to solve a live coding exercise during your interview with time constraints, practice it beforehand. There is an approach that makes it much easier to deal with coding exercises:

Understand the problem statement, and try to rephrase it in your own words.
Make up or take a look at test input-output examples.
Describe your approach to solving the problem. Demonstrate how it will work on the input-output examples.
Write your code according to the standards of the programming language.
Estimate the complexity of an algorithm using the Big O notation. Think about how to optimize it.

Keep in mind that interviewers evaluate not only your solutions. They also pay attention to your way of thinking and communicating, your depth of knowledge, and whether or not you can write well-readable code.

Good luck with your interviews, and have interesting projects!

Testing and Benchmarking in Go

Hermann Rösch — Thu, 27 Apr 2023 11:53:22 +0000

Introduction

Testing is a crucial aspect of software development that helps ensure the quality and reliability of your code. In Go, testing is built into the language through the testing package, which makes it easy to write and execute tests for your programs.

Tests are essential because they:

Validate the correctness of your code, ensuring that it behaves as expected under various conditions.
Provide a safety net for future modifications, allowing you to make changes with confidence that you won't inadvertently break existing functionality.
Act as documentation complement for other developers, demonstrating how the code is supposed to work and serving as a guide for using and modifying it.
Facilitate better code design, as writing tests often encourages developers to create modular and reusable components.

For Go developers, incorporating tests into the development process can lead to more reliable and maintainable code, ultimately improving the overall quality of your applications.

In this article, you'll learn how to write and run table-driven tests and benchmarks in Go. If you're new to testing or feel uncertain about the topic, read the Introduction to Testing in Go topic on Hyperskill, which covers the basics of tests in Go.

Table-Driven Tests 📋🧪

Table-driven tests are a typical pattern in Go for testing multiple input and output cases using a single test function. Instead of writing separate test functions for each case, you can define a table (a slice of structs) that includes the input values, expected output, and an optional description for each test case. You can then loop through the table and execute the test function for each case.

Compared to individual unit tests, table-driven tests offer several advantages:

They reduce code duplication and make your test suite more maintainable.
They make it easy to add new test cases, as you simply need to extend the table.
They provide a clear overview of the various input-output combinations being tested.

Let's get started! First, create a new Go project named example and initialize Go modules via the following commands:

mkdir example && cd example
go mod init example

Then create a new file main.go and within it, let's write the code of the DiscountedPrice() function that calculates the discounted price of a product:

// main.go

package main

import "fmt"

// DiscountedPrice calculates the discounted price of a product,
// given its original price and discount percentage.
func DiscountedPrice(price, discountPercent float64) (float64, error) {
    switch {
    case discountPercent == 0:
        return price, nil

    case discountPercent < 0:
        return 0, fmt.Errorf(
            "invalid negative discount percentage: %.2f",
            discountPercent)

    case discountPercent > 100:
        return 0, fmt.Errorf(
            "invalid discount percentage greater than 100: %.2f",
            discountPercent)

    default:
        discount := price * (discountPercent / 100)
        return price - discount, nil
    }
}

The next step is to create a new file main_test.go, and within it, write a table-driven test for the DiscountedPrice() function:

// main_test.go

package main

import "testing"

func TestDiscountedPrice(t *testing.T) {
    testCases := []struct {
        price           float64
        discountPercent float64
        expected        float64
        expectError     bool
        desc            string
    }{
        {100.0, 0.0, 100.0, false, "no discount"},
        {100.0, 50.0, 50.0, false, "50% discount"},
        {100.0, 100.0, 0.0, false, "100% discount"},
        {100.0, 110.0, 0.0, true, "discount greater than 100%"},
    }

    for _, tc := range testCases {
        t.Run(tc.desc, func(t *testing.T) {
            result, err := DiscountedPrice(tc.price, tc.discountPercent)
            if tc.expectError && err == nil {
                t.Errorf(
                    "DiscountedPrice(%.2f, %.2f) should return an error",
                    tc.price, tc.discountPercent)
            }
            if !tc.expectError && err != nil {
                t.Errorf(
                    "DiscountedPrice(%.2f, %.2f) returned an error: %v",
                    tc.price, tc.discountPercent, err)
            }
            if !tc.expectError && result != tc.expected {
                t.Errorf(
                    "DiscountedPrice(%.2f, %.2f) = %.2f; want %.2f",
                    tc.price, tc.discountPercent, result, tc.expected)
            }
        })
    }
}

Running tests 👨‍🔬🖥️👩‍🔬

To run the tests, you can use the go test command to execute all test functions in the package and report the results. By default, go test runs all tests for the current package. However, you can also provide a package name, a directory, or a list of packages to test multiple packages simultaneously.

After executing the go test command, you should see the following output:

> go test
PASS
ok      example 0.236s

PASS indicates all the tests have passed, ok confirms that the text execution was successful, example is the name of the Go module being tested, and 0.236s is the duration of the test execution in seconds.

Even though all tests passed, how can you be sure there were no untested code paths left? The answer is simple you will need to check the test coverage.

Running tests with coverage 📄🔍

Test coverage is a metric that measures the proportion of your code that is exercised by your test suite. High test coverage indicates that your tests are comprehensive, while low test coverage suggests that some parts of your code may not be adequately tested. By tracking test coverage, you can identify untested portions of your code and write additional tests to improve the reliability of your application.

To run the tests with coverage, use the go test -cover command. It will execute all test functions in the package, report the results, and provide a coverage percentage indicating the proportion of your code exercised by your tests.

> go test -cover
PASS
coverage: 85.7% of statements
ok      example 0.253s

After examining the output, the coverage is only 85.7%, which indicates that one of the code paths wasn't tested. Upon closer inspection, you might notice the absence of a test case for the "negative discount" scenario.

To improve test coverage, you can add the "negative discount" test case below to the testCases slice:

{100.0, -10.0, 0.0, true, "negative discount"},

Then run go test -cover once again, and you should get 100% coverage:

> go test -cover
PASS
coverage: 100.0% of statements
ok      example 0.250s

It's important to remember that while achieving high test coverage is a good practice, the primary focus should be on writing meaningful tests that cover a wide range of inputs and edge cases rather than just aiming for 100% coverage.

Benchmarking 📊

Now that you're familiar with testing let's move on to benchmarking. Benchmarking is a valuable technique to measure the performance of your code, helping you identify bottlenecks and optimize your functions for better efficiency.

Benchmarks can be beneficial for developers in Go when comparing the performance of different implementations, optimizing code for specific use cases, or determining the impact of a change in the codebase.

For instance, suppose you want to compare the efficiency of various approaches to a common problem, like string concatenation, to optimize your code's performance and minimize memory allocations. By benchmarking different methods, you can make more informed decisions about the best way to implement a particular feature or operation in your application.

Let's write benchmarks to compare the performance of three different string concatenation methods:

Using strings.Builder and its WriteString() method.
Using the += operator for string concatenation.
Using fmt.Sprintf() for string concatenation.

First, create a new file called benchmarks_test.go and add to it the following code:

// benchmarks_test.go

package main

import (
    "fmt"
    "strings"
    "testing"
)

func BenchmarkStringBuilderConcatenation(b *testing.B) {
    for i := 0; i < b.N; i++ {
        var sb strings.Builder
        for j := 0; j < 1000; j++ {
            sb.WriteString("h")
        }
        _ = sb.String()
    }
}

func BenchmarkStringConcatenation(b *testing.B) {
    for i := 0; i < b.N; i++ {
        var s string
        for j := 0; j < 1000; j++ {
            s += "h"
        }
    }
}

func BenchmarkFmtSprintfConcatenation(b *testing.B) {
    for i := 0; i < b.N; i++ {
        var s string
        for j := 0; j < 1000; j++ {
            s = fmt.Sprintf("%s%s", s, "h")
        }
    }
}

Running benchmarks and comparing results 🚀📈

You can use the command go test -bench . to run benchmarks. This command will execute all benchmark functions in your code once. Nonetheless, remember that benchmark outcomes may be prone to variations.

In order to achieve precise and dependable results, it's crucial to carry out benchmark tests repeatedly and evaluate the results. This process lets you detect discrepancies and better comprehend your code's performance attributes.

You can run benchmarks multiple times using the -count flag. Additionally, you can include the -benchmem flag to gather memory allocation statistics for each benchmark.

Let's go ahead and run the benchmarks with -count 10 and -count 20 to compare the performance:

go test -bench . -benchmem -count 10 > 10_runs_bench.txt
go test -bench . -benchmem -count 20 > 20_runs_bench.txt

Now you have the results from two sets of benchmarks with 10 and 20 runs each. To compare these results, you can use benchstat, a command-line tool that helps analyze and compare benchmark results:

go install golang.org/x/perf/cmd/benchstat@latest

After installing benchstat run the following command to compare the results:

> benchstat 10_runs_bench.txt 20_runs_bench.txt           
goos: windows
goarch: amd64
pkg: example
                              │ 10_runs_bench.txt │           20_runs_bench.txt           │
                              │      sec/op       │   sec/op     vs base                  │
StringBuilderConcatenation-12         2.385µ ± 2%   2.315µ ± 1%  -2.96% (p=0.000 n=10+20)
StringConcatenation-12                171.2µ ± 2%   163.6µ ± 3%  -4.46% (p=0.000 n=10+20)
FmtSprintfConcatenation-12            241.2µ ± 5%   240.5µ ± 2%       ~ (p=0.619 n=10+20)
geomean                               46.18µ        44.99µ       -2.58%

                              │ 10_runs_bench.txt │            20_runs_bench.txt             │
                              │       B/op        │     B/op      vs base                    │
StringBuilderConcatenation-12        3.242Ki ± 0%   3.242Ki ± 0%       ~ (p=1.000 n=10+20) ¹
StringConcatenation-12               517.8Ki ± 0%   517.8Ki ± 0%       ~ (p=1.000 n=10+20)
FmtSprintfConcatenation-12           533.8Ki ± 0%   533.8Ki ± 0%  +0.00% (p=0.034 n=10+20)
geomean                              96.42Ki        96.42Ki       +0.00%
¹ all samples are equal

                              │ 10_runs_bench.txt │            20_runs_bench.txt            │
                              │     allocs/op     │  allocs/op   vs base                    │
StringBuilderConcatenation-12          9.000 ± 0%    9.000 ± 0%       ~ (p=1.000 n=10+20) ¹
StringConcatenation-12                 999.0 ± 0%    999.0 ± 0%       ~ (p=1.000 n=10+20) ¹
FmtSprintfConcatenation-12            1.998k ± 0%   1.998k ± 0%       ~ (p=1.000 n=10+20) ¹
geomean                                261.9         261.9       +0.00%
¹ all samples are equal

You'll see a table with multiple columns when comparing benchmark results using the benchstat command. Let's break down each column from left to right:

Function name: The name of the benchmark function, such as StringBuilderConcatenation-12.

Time per operation: The average time it took to complete one operation for each benchmark file, represented in seconds or microseconds (e.g., 2.385µ ± 2% for 10_runs_bench.txt and 2.315µ ± 1% for 20_runs_bench.txt). The percentage value represents the standard deviation, which indicates the variability of the execution time.

Time difference: The percentage difference in the average execution time between the two benchmark files (e.g., -2.96%). The p-value (e.g., p=0.000) helps determine if the difference is statistically significant. A p-value of 0.05 or lower typically indicates statistical significance, and a negative value indicates that the second benchmark file has faster execution times.

Bytes allocated per operation: The average number of bytes allocated per operation for each benchmark file (e.g., 3.242Ki ± 0% for both files). The percentage value represents the standard deviation.

Memory difference: The proportionate disparity in the mean memory allocation between the two benchmark files (e.g., ~ (p=1.000 n=10+20)). The p-value aids in establishing the statistical significance of the difference.

Number of memory allocations per operation: The mean number of memory allocations per operation for each benchmark file (e.g., 9.000 ± 0% for both files). The percentage figure denotes the standard deviation.

Allocation discrepancy: The percentage divergence in the average number of memory allocations between the two benchmark files (e.g., ~ (p=1.000 n=10+20)). The p-value assists in determining the statistical significance of the difference.

Geomean: The geomean row at the bottom of each table displays the geometric mean of the values for each column, providing an overall summary of the benchmark results.

Finally, based on the benchmark results, we can determine that:

Using a string builder with the WriteString() method is the best choice for performance and memory efficiency, mainly when dealing with numerous concatenations or resource-limited environments.

Using string concatenation with the += operator and fmt.Sprintf() is slower and less memory-efficient than using a string builder. They may be suitable for more straightforward tasks where performance is not a top priority or readability and ease of use are more important.

Wrapping up 📝

To sump up, testing and benchmarking are essential aspects of Go development, ensuring code reliability, efficiency and quality.

If you want to keep learning about Go software quality, you can take a look at some other topics with great theory and practical problems on Hyperskill:

Soon, you'll also be able to learn more about software quality, testing, and benchmarking in the upcoming Go for Developers track that is in the works right now, so keep an eye on the Hyperskill blog for future announcements!

And if you want to learn the fundamentals of the Go programming language along with essential Computer Science concepts 💻, you can start your learning journey today with the Introduction to Go track on Hyperskill!

Let us know in the comments below if you have any questions or feedback regarding this blog. You can also follow us on social media to stay up-to-date with our latest articles and projects. We are on Reddit, LinkedIn, and Facebook.

Thank you for reading, and keep on coding!

Telegram Conversation Summarizer Bot with ChatGPT and Flask (Quart)

aliona matveeva — Fri, 21 Apr 2023 12:00:00 +0000

Everybody talks about ChatGPT right now. The exceptionally smart AI keeps dazzling the internet even a couple of months after its release. Having the ChatGPT available on the website is awesome, however, the real fun begins when you gain API access. This gives you a great opportunity to integrate smart AI into your projects and applications to make them more powerful and introduce amazing features.

This article brings you a guide on how to create your own Telegram bot and integrate ChatGPT with it, using the OpenAI's Python library. This may sound like the simplest thing to do, but let's spice things up a bit by introducing the summarize command to get you a summary of several posts in the chat.

The post assumes you have basic knowledge of Python. However, I recommend checking out Hyperskill's Python and Flask tracks to learn more about Python and developing web applications with Flask.

Setting everything up

Before jumping right into the code, you'll need to do some preparations to get all the required accesses.

Register your bot in Telegram and retrieve the Telegram access token (using @botfather in Telegram)
Get access to the Telegram Core API and retrieve api_hash and app_id.
Sign up to OpenAI and retrieve the API access token.

Save those secret strings and guard them with your life. No stranger should get access to them: this may lead to security violations.

Writing the skeleton

Note: the full final project code (split into stages with commits) is available on my GitHub, please refer here for details: https://github.com/yellalena/telegram-gpt-summarizer

Python libraries you need to install for this step: flask, pydantic, requests, and pyngrok.

Let's begin with writing the code for the very basic Telegram bot. It should receive messages from chat and be able to respond to them.
First thing first - create a directory for your project and initialize a Python virtual environment. By the way, if you use PyCharm, it will create a virtual environment for you.

At this stage, the goal is split into four parts:

Create a simple Flask app with one root route to handle webhook with telegram messages.
Create a class for the Telegram bot and make it able to send messages to a chat.
Make the application visible to the big internet.
Register the application address in Telegram.

This is what main.py looks like at this point:

app = Flask(__name__)

@app.route('/', methods=["GET", "POST"])
def handle_webhook():
    update = Update(**request.json)
    chat_id = update.message.chat.id

    response = f"This is a response for message: {update.message.text}"
    app.bot.send_message(chat_id, response)

    return "OK", 200

def run_ngrok(port=8000):
    http_tunnel = ngrok.connect(port)
    return http_tunnel.public_url

def main():
    app.bot = TelegramBot(Config.TELEGRAM_TOKEN)
    host = run_ngrok(Config.PORT)
    app.bot.set_webhook(host)
    app.run(port=Config.PORT, debug=True, use_reloader=False)

if __name__ == "__main__":
    main()

Few things need clarification:

I like to put all configuration things in one place, so I created the config.py file, which will be gathering and storing our tokens and other useful information from exported environment variables.
Telegram sends updates as a nested JSON, so let's create a set of pydantic models to parse the input to be more convenient later.
To expose the application to the web, I use ngrok. It makes your localhost's specific port visible to everyone else, giving it a temporary public address. This is why it's important to make sure you expose the same port you're running your Flask app on.
Finally, I initialize the bot and set a webhook to the ngrok's public URL, so that the bot knows it has to communicate to this URL whenever it receives any message.

To set up a webhook, you will need to send a request to your bot's telegram API address, built using your acquired secret token. The telegram bot code looks as follows:

import requests
from config import Config

class TelegramBot:
    def __init__(self, token):
        self.token = token
        self.bot_api_url = f"{Config.TELEGRAM_API}/bot{self.token}"

    def set_webhook(self, host):
        host = host.replace("http", "https")
        set_webhook_url = f"{self.bot_api_url}/setWebhook?url={host}"
        response = requests.get(set_webhook_url)
        response.raise_for_status()

    def send_message(self, chat_id, message):
        send_message_url = f"{self.bot_api_url}/sendMessage"
        response = requests.post(send_message_url, json={"chat_id": chat_id,
                                                          "text": message})
        response.raise_for_status()

Now that everything is ready (don't forget I omitted some of the basic code, you can find it in the repo), export your bot token in an environment variable and hit that "Run"!

Yay! It's alive!

Adding a brain

Amazing, the next step now should be adding a pinch of intelligence to our smart bot. Install an official OpenAI's lib for Python using pip: pip install openai.
After that, we will be able to create a helper class to communicate with the AI.

import openai

class OpenAiHelper:
    def __init__(self, token, model="gpt-3.5-turbo"):
        openai.api_key = token
        self.model = model

    def get_response(self, message_text):
        response = openai.ChatCompletion.create(model=self.model,
                                                messages=[{"role": "user", "content": message_text}])
        return response.choices[0].message.content

The API suggests a variety of models to use for your project. The most popular are, of course, the GPTs. GPT-4 is the one that made the most noise lately, but (and because of that) it has limited access now, so for easier testing purposes, I choose GPT-3 instead. No big deal, you can always choose whichever you like the most, just change the string name you pass to the helper.

Don't forget to add OPENAI_TOKEN property to the config and let's use the helper in the code.

First, of course, instantiate it in the main() method:

And then call this guy from the view function, just like that:

response = app.openai_helper.get_response(update.message.text)

Whoosh! The magic is happening!

Summarize it!

Python libraries to install for this step: quart, telethon.

I bet you've been there - you have been added to a chat with a group of friends who like to discuss interesting things or share some news or ideas. You've had a lot of stuff to do and you've missed all the fun in the chat. Next thing you see - a hundred unread messages there. Wouldn't it be nice if someone could give you a brief overview of what happened there instead of reading all that? Well, GPT can do that, of course. We only need to ask it.

This is where the fun begins. For some reason, Telegram's bot API doesn't allow bots to read conversation history. We have webhooks, and we have the explicit GetUpdates() method, but they only work if someone has mentioned the bot. Another option is to make the bot get all the updates if it's added as an admin, but this approach has a few cons as well. First, you would need to set up whole storage for the messages. Second, what if you want to summarize the conversation that was going on before the bot was added to the chat? Not our case.

Obviously, that's not the reason to give up. Telegram provides the Core API, and this one can help with retrieving a chat history. The only thing is that it's asynchronous. And the most popular Python library for it, Telethon, is asynchronous, too. And Flask is synchronous. Uh-oh.

And that's where the mysterious Quart mentioned in the title comes onto the stage. Quart is the Flask API re-implemented using async, await, and ASGI web server (rather than synchronous and WSGI). Its main advantage in our case is that the syntax is basically the same. Let's do a quick code reorganization.

The changes are simple. First, adjust imports and change every Flask to Quart:

Then, make all web application's methods async. And await all the properties and methods that have become asynchronous now:

If you're not sure about what's async Python, I encourage you to check this part of Telethon documentation on the asyncio basics.

I have also moved ngrok and TelegramBot to launch them in a separate method decorated with @app.before_serving. This is a Quart built-in decorator that will ensure everything inside this method will run before the web app is up and serving. It's required so that the bot and the helper are both initialized in the same event loop as the main application.

@app.before_serving
async def startup():
    host = run_ngrok(Config.PORT)
    app.bot = TelegramBot(Config.TELEGRAM_TOKEN)
    app.bot.set_webhook(host)
    app.openai_helper = OpenAiHelper(Config.OPENAI_TOKEN)

Running the app has slightly changed as well, but not much. Hypercorn is the ASGI server used to run Quart asynchronously, and if we want to specify an application's port, we need to do it in a config. Note that the main() is now also async and is run using asyncio:

async def main():
    quart_cfg = hypercorn.Config()
    quart_cfg.bind = [f"127.0.0.1:{Config.PORT}"]
    await hypercorn.asyncio.serve(app, quart_cfg)

if __name__ == "__main__":
    asyncio.run(main())

That's it. Let's check if the changes went smoothly for our bot. Run, text, enter:

It's speaking. Great. Now, get the chat history for AI to summarize. Let's use Telegram's Core API with the help of Telethon lib. There, we will need the last two secret strings you have - export them as environment variables too.

TelegramBot has slight changes in the __init__ method: it will need to have a new core_api_client property which initializes a Telethon's client and of course, you need to pass the Core API secrets as arguments.

And this tiny method will be responsible for retrieving the history:

async def get_chat_history(self, chat_id, limit=30):
        if not self.core_api_client:
            return []
        history = await self.core_api_client.get_messages(chat_id, limit)
        result = [f"{message.sender.first_name} {message.sender.last_name}: {message.message} \n"
                  for message in history if not message.action]
        result.reverse()
        return '\n'.join(result)

Telethon's get_messages has many more different parameters you can pass beside the limit ones. For example, it can reverse the history, or limit it by date instead of the number of messages. It's fun to play with and you can adjust your own bot in any way you'd love to.

Well, we're almost done. The final touch is to add a summarization option to the webhook handler. This is what getting an answer looks like:

# process "summarize" command
    if update.message.text.startswith("/summarize"):
        history = await app.bot.get_chat_history(chat_id)
        response = app.openai_helper.get_response("Please, briefly summarize the following conversation history:\n" +\
                                                  history)
    else:
        response = app.openai_helper.get_response(update.message.text)

    app.bot.send_message(chat_id, response)

Let's see it blooming!

After you run the application for the first time, it will ask you to log in to Telegram. That's ok: it's required to get access to message history and other private data the Core API has to offer us. Enter the same phone number you used to get access to Telegram Core API. You will receive a verification code inside your app, and after that you're good to go.

Add the bot to a conversation with friends and ask for a summary:

That's it! There's an endless list of things you can continue with: add processing other types of messages besides text, configure a number of messages to summarize from the chat, etc. Go for it and don't forget to push your code onto GitHub. Happy coding! :)

Don't forget to jump onto Hyperskill website to keep learning about developing web applications with Python and Flask. Here are links to some topics that you might find useful exactly for this project:

Error handlers: If you don't handle errors properly, there is a high chance of your application failing in the runtime or showing ugly tracebacks to the user. To avoid that, read about types of errors and how it's best to handle them in a Flask app.
Logging: That's one of the most important things when it comes to testing and debugging your application. Writing meaningful and readable logs is a must for a software developer. Check this topic to learn how to perform logging in Python.
Intro to SQLAlchemy: When you decide you want to store some application data, whether it be any user info or conversation history, you will need to communicate to the database. This topic introduces you to the basics of SQLAlchemy which makes working with databases easy and convenient.

Hyperskill is a project-based learning platform that offers a personalized curriculum and a variety of tracks to help people from different backgrounds gain market-relevant skills through online education. It's not only giving you solid pieces of theory but allows you to practice the skills right away - and practice makes learning perfect.

Did you find this post helpful? Hit clap and follow Hyperskill and me to read more of them later :)