Create your first Flask application

Mariia Kornieva — Mon, 17 Aug 2020 07:36:16 +0000

Flask is a micro web framework. It means that it is lightweight and extensible. By no means, Flask lacks in functionality due to its 'micro' nature.

To create a basic Flask application, you have to go through the following steps:

Set up a Python virtual environment in your project directory.

There are a lot of options here. I use the built-in module venv. In order to activate it you need to execute next commands:
```
$ python3 -m venv venv
$ source venv/bin/activate
```
Once you're done, execute this to deactivate your virtual environment.
```
$ deactivate
```
Install Flask in this virtual environment with:
```
python3 -m pip install flask
```
Create a python file for your application. I usually call it server.py.
Flask uses special environment variables FLASK_APP and FLASK_ENV when you start a flask application.
- FLASK_APP should be assigned to the name of the file that Flask should run. In our case, it is server.py that we've just created.
- FLASK_ENV is used to toggle the Debug mode for the Flask app.
To set up those execute following commands in your shell:
```
$ export FLASK_APP=server.py
$ export FLASK_ENV=development
```
We are ready to create our first Flask app! In the server.py add the following:
```
from flask import Flask
app = Flask(__name__)
```
In this code snippet, we imported the Flask class, which represents a flask application. On the second line, we create an instance of that class and pass the __name__ variable to it. __name__ is assigned to the string __main__ if the python module is executed, otherwise, it is assigned to the name of a module if it is imported.
Then add the following function definition to your flask app:
```
@app.route('/')
def index():
    return 'Hello, World!'
```
Here we use the decorator @app.route('/') (decorator is a way of adding functionality to a function without altering that function implementation) to bind the specified URL with the function that should get called once the user tries to access that URL. In our case, we add a base URL / and bind it to the function index, which will return a string Hello, World!.
In order to run this application, execute the following command:
```
$ flask run
```
In your browser, go to the 127.0.0.1:5000, and if you have set up everything correctly, you will be able to see Hello, World! in your browser window.

In the next blog post, I will cover how to use HTML templates and template inheritance using the Jinja templating engine, to utilize the fundamental principle of software design, the DRY principle. Stay tuned!

Learning Tips for Software Engineers

Mariia Kornieva — Sat, 15 Aug 2020 10:32:46 +0000

We all struggle to learn new things. It is tough, but in the end, it's gratifying.

It's easy to passively watch dozens of tutorials, seeking inspiration and motivation to start building your next project finally. But the truth is that when you actually start developing, you struggle. What seemed so easy on a video is hard to do if you aren't used to it.

I have been through this process a lot of times, but I adopted two handy techniques that help me learn easier. Those two are active recall and spaced repetition.

Active Recall means that in order to learn something, you need to retrieve information from your brain actively. This is exactly the reason why you feel like you better understand concepts when you teach others or when you're writing a blog post, making a video, you name it. All of these involve a lot of active recall.

Traditionally flashcards are used to make use of the active recall technique. However, I haven't found flashcards useful when learning to code. In my opinion, the best way to practice active recall as a programmer is to build projects! Just think about it. Every time you start a new project, you often go through many similar steps again and again.

Let's take CSS as an example (I've been learning it lately). Every single time you need to style a new webpage, you make use of the same properties over and over again, you position elements using flexbox or CSS Grid over and over again. And every single time, you have to retrieve the styling and positioning information from your brain, or if it's not yet in your brain, you need to upload it into it. That is a perfect use of active recall. And that is the reason why you don't need to learn all CSS properties by heart ahead of time. When you start applying them, it will be just uploaded into your brain. Consistency is the key!

Spaced Repetition is about deliberate repetition over time. Basically, it uses active recall as a method of repetition, since it is the most effective one.

Spaced repetition is a vital technique due to the fact of what's known as a forgetting curve. You forget most of what you learn in the first 24 hours. To reduce this rate of memory decay, you should repeat what you've learned. I highly recommend reading this webpage. It contains a fantastic explanation of the science behind the forgetting curve phenomenon. Hope it will convince you that repetition is crucial.

The most important fact is that these two techniques work if and only if they are applied together. It would help you if you built a durable and long-lasting habit of repeating learned concepts to make them stick.

So the next time you're watching a tutorial or reading a book, try to do the following:

Repeat what you've just read
Code an application you've just seen in the tutorial
Tell others about what you've learned
Repeat!

Yes, it takes time, but it leads to long-lasting fundamental knowledge that you can use to build upon when learning more advanced topics. And as for learning, it's a continuous process.

Thanks for reading my post and happy learning!

DEV Community: Mariia Kornieva

Create your first Flask application

Learning Tips for Software Engineers