

## Overview
In this tutorial, I'll deomnstrate how to create a flask app with two simple functions. Read a json and write to a json. No more, no less. This is because for simple sites, such as for personal use or to display a small project, a simple backend is all that's neccessary. With no SQL, no databases, just a json and an app.

## Stack
I used Python for its popularity, readability, and ease of use. The Flask framework, while primarily used as its own web development framework, is very useful for hosting simple backend data structures thanks to its simplicity. 

## Getting started
Create the project: 
```.bash
mkdir project
```
In your project directory add or initiate the json you wish to manipulate; I'll call mine 'person.json':
```shell
touch person.json
```
You'll want to add some data, so you have something to work with: 
```json
{
  "name": "anton", 
  "age": "19", 
  "skill-level": 9000
}
```

Now create an app directory (still within the project directory): 
```shell
mkdir app.py 
```
In the app directory create a python file called `main.py` ; this is where we'll create the app: 
```shell
touch main.py
```

## Building the app
First of all, let's import all of our dependencies. We'll just need the 'flask' class (from the Flask framework) and the 'json' API (python's inbuilt API used to work with json files). 

At the top of the file write: 

```py
from flask import Flask
import json
```

We then create an instanciation of the Flask class:
```py
app = Flask(__name__)
```

Now, we'll need two functions, which we can call on our json: one to read and one to write. I'll show each of the functions below, with a short descrpiton of how they work.

## Reading the Json

```py
def readFromJson(j): 
    file = open(j,'r')
    data = json.load(file)
    return data
```

First of all, we pass in the name of the file we want to read with a string `'j'`.

Now to access the file we use `open()` which takes two parameters: our file `'j'` and the `mode` in which we want to open it. We'll use `'r'` as we are *reading* the file. 

We assign the opened file to a variable `'file'`.

Then parse (i.e. read) '`file`' using `json.load()`. This converts the data in the json to a python dictionary.

We assign this to a variable `'data'` and return it.

*N.B.* `json`s and python dictionaries have an almost identical structure, allowing us to convert between them with no loss in information.

## Writing to the Json

In this example we are replacing a person's data, i.e. name, age, skill level. 
```py
def writeToJson(j, object, value):
    file = open(j, 'r+', encoding='utf-8')
    data = json.load(file)
    data[object] = value
    f.seek(0)
    json.dump(data, file)
    file.truncate()
    file.close()
```


To write to a json we pass in three parameters. 

The json file we are writing to:

```
    j (string)
```

An object whose data we want to alter: 

```
    object (string)
```

Some information to give to the object 

```
    value (any json supported data type )
```

As before, we `open` and `load` the file so that we have a dictionary with the contents of the json.

You might notice we also included *encoding* parameter. We chose `utf-8` as this is the standard unicode bit size, though this is essentially just a precaution.

We then access the object we want to change in the dictionary with `data[object]`, and assign it the new information.

Now that we've loaded the file, we move the cursor back to the start of the json with `f.seek(0)`, then use `json.dump()` to update the file.

For good practice, we have `file.truncate()` and `file.close()`. 

`truncate` will change the file size if the new data is smaller than the previous, and `close` will close the file.

## Adding App Routes

The app routes simply give us somewhere to call our functions. They are python functions which, when we host the app, can be accesed through url routes.

We set the default url to call the `readFromJson()` function:

```py
@app.route("/")
def getJson():
    return readFromJson('person.json')
```

Then we have to crate a route which calls `wirteToJson()`. We have three objects in our json, we can name the route depending on which object we want to write to. I'll use `name` as an example: 

```py
@app.route("/setName")
def setJson():
    newName  = request.args['name']
    writeToJson('person.json', name, newName)
```

To call this function and pass in our new data, we use a URL query. Simply add `?` after the url and specify the argument:

```
https://example.com/setName?name=shmanton
```
Then `request.args['name']` picks up this query and assigns our new value to `newName`, which is passed into `writeToJson()`.

## Test it out! 

Create another python file called wsgi.py in your project directory (not within app). 
    
*Note:*
`'wsgi'` stands for Web Server Gateway Interface and is just a calling convention used for web servers to forward requests to web apps.

In `wsgi.py` write:

```py
from app.main import app
if __name__ == "__main__":
    app.run()
```

This simply imports and runs our app, so if we want to try it out, all we need to do is run the wsgi.

```py
$ python3 wsgi.py
```

`Crtl` click on the link provided (usually http://127.0.0.1:5000) to view your json. This url is running our getJson() function.

Now we can use routes and queries just as in the example above:
```
http://127.0.0.1:5000/setJson?name=shmanton
```
#### before
```json
{
  "name": "anton",
  "age": 19,
  "skill-level": 9000
}
```

#### after
```json
{
  "name": "shmanton",
  "age": 19,
  "skill-level": 9000
}
```
And that's it! Your very own mini database. You can easily change the functions we wrote to allow you to edit your json further (i.e. append, overwrite, etc.). 

Use cases include an online leaderboard, a commenting system, or even my very own [bordle](https://antongomes.com/bordle) project!

If you want to deploy your app, I highly reccomend Heroku. It's free to use, easy to understand ad has excellent documentation. And the cherry on top... **I have a tutorial coming soon!** 

Of course you can use [the official tutorial](https://devcenter.heroku.com/articles/git) in the meantime, promise I won't take offence ;).


Need a quick and easy backend server? Read on to learn how to read and write a JSON the using Python and the Flask framework.

Making a Lightweight Backend JSON with Flask

**Hey! I'm Anton. A 19 year old Scottish/Portuguese student at Edinburgh University and aspiring software engineer. 🏴󠁧󠁢󠁳󠁣󠁴󠁿🇵🇹**

I was introduced to programming through a school project a few years ago. Now, after becoming increasing enthralled by the possibilities and power of coding, I've let an _obsession_ with the field come over me. 

This passion for programming not only led me to study Computing Science at the University of Edinburgh, but has now given me the drive to pursue a career as a software engineer. 

In my spare time I use my creativity, attentiveness to detail, and focus to imagine and build original projects. I thrive on the sense of achivement these projects permit. 

The rapid progress coding allows for always amazes me. From something as significant as picking up a new language or finishing a build; to the everyday triumphs such as learning a new command or fixing that bug that's been bothering me. 

I am resourceful and able to develop my coding skills independently. Being conscious of my learning practice, and equipped with learning resources, I am able to tackle coding challenges I am faced with. 



Who doesn't love talking about themselves? A simple expansion and continuation of the introduction section of my CV.

About Me



Some notes I've taken over the years on how to focus. I'll definitely update this as I go.

My credentials for this are none other than the fact that I am terrible at being productive. 

---

## Deep Work

Deep work is the kind of work that really pushes the limits of what you can do, it requires complete focus and allows us to do what we know we can but rarely manage to. Importantly, we cannot be in deep work all the time, there's a maximum of around 4 hours or less for most people, and yes, you are most people.

### Build the environment

Even the action of mindfully choosing the environment you think works best for you helps to put you in the right mindset. Dedicate a total time for deep work, set the requirements of what you need beforehand. That is, do not change the scenery during deep work—same drink, same music, same place.

### Planning ahead

**Schedule every minute**, but acknowledge that this will not go as planned. The more you do it the better you will get at it. This is super important, no matter how busy, it is always better to have a plan. The point of time blocking isn’t to create a schedule you can stick to perfectly each day. Instead, this exercise forces you to be more intentional with your time and how you direct your attention.

**Focus on the widely important.** Try to keep most important goals at the forefront, dedicate the most time to these goals.

**Breaks are not optional**, they help *unlearn* the wrong solutions—sounds silly but it is absolutely true. Decide how you will spend your breaks. The best things to do are to move and talk. Social interaction is especially useful as it is more distracting than just going on a walk. Although breaks should be no longer than 15 minutes. Be disciplined with this.

### In the mud

**You want this.** When you're *in the mud*, that is, actually working, the motivation should primarily derive from the fact that you want this and you chose this. This is intrinsic motivation.

**Give yourself the satisfaction**, track how many hours you've worked. I like to keep a stopwatch up on my screen at all times, this way I can see how long I've been focused for. This provides a weird recursive loop where I feel good about having focused for X minutes/hours which motivates me to stay focused longer. This also works towards the end of the session where you can tell yourself "only Y minutes left!"

**Remove the option of distraction.** Being distracted is a choice, the sooner you realise this the better. If you don't want to be distracted then remove all distractions. If you keep using your phone then put it in another room or leave it at home. I guarantee the excuse you tell yourself as to why you need to keep your distraction around, keep notifications on etc is just that—an excuse. The best tool I have found for this is Opal. I use this to block every app on my phone and laptop which is not essential to the work I am currently doing.

**Recognise thought patterns.** If you catch yourself thinking about anything that is not the task at hand, notice it and bring your attention back. Identify thought loops—if you find yourself going in circles, make an active decision that will change this and move to the next step.

---

## Myths

**There's no such thing as "I don't have time".** You choose how to spend all of your time. You can make excuses for the gym and for projects but really, if you changed your priorities you wouldn't have to.

**Motivation is not real.** To get from thought to action we only need discipline.

**Choose to not be distracted by removing all distractions.** Tools such as Opal can facilitate this, also you could place your phone in a different room or leave it at home.

---

## Laws

**Parkinson's Law** — Tasks expand to fill the time they are allocated.  
The best way to work around this is the following exercise:
- Make a list of 3–4 long-term tasks you want to do.
- How would you do them if you only had half as long?
- How would you do them if you had one day?

**Pareto Principle** — 80/20 rule: the first 20% of input is probably where all the value came from.  
Identify what 20% of work is deriving 80% of useful output and vice versa—what's taking up 80% of your time and not contributing much to your outcomes?

**Newton's First Law** — Objects in motion stay in motion, objects at rest stay at rest.  
If a task takes less than 2 minutes to do, just do it—don't put it on the to-do list.  
If you don't want to do a task, do 5 minutes of it.  
Lower the activation energy: if you don't want to work, make a cup of coffee and set up the workspace, clean desk, so all you have to do is sit down.

---

## Powers

### Habits

You need to change the view you have of yourself to what matches your goals. If I view myself as a productive person then doing anything unproductive would just feel wrong.

### Productive down time

Use small bits of downtime—like a break at work or taking a shit or commuting—to get things done. Make it easy to do these things by having them accessible.

### Productive procrastination

Is what it says on the tin.

### Fun Factor

Making things fun is the best hack. Make the task social or gamify.

---

## Misc

**The craftsman approach to tool selection**:  
Identify the core factors that determine success and happiness in your professional and personal life. Adopt a tool only if its positive impacts on these factors substantially outweigh its negative impacts. Reddit and Instagram are not such tools.

**Work with my brain not against it.**  
Need to train my brain to keep good habits, it won't happen just because I want it to. I'm so used to bad habits that it needs practice to break them.

Notes i took during my undergrad degree on how to focus.

🏠

Anton's Blog

Making a Lightweight Backend JSON with Flask

About Me

Productivity Notes