Backend from beginner to expert is a series where I share my experience as a backend software engineer, what you need to know as a beginner, and how to improve yourself to be an expert.
Introduction
This article will introduce the fundamental of backend: server. What is a server? How does it work? And how to build a daemon server.
What is a Server
To better get start, you must have a basic understanding of computer.
Computer is a compute machine, like calculator. They could perform calculation process, with different input and output, here is a comparison.
| Calculator | Computer |
Input | number, and operator | mouse movement, keyboard typing, data from hard drive and network |
Output | number | monitor, data into disk or network |
Computer take input and get output by application running on it.
Application is actually a set of instructions tell computer how to process the input and how to generate output.
Server is an application which take network user request as input, and get output and send back to user.
For example, when you open https://www.google.com in browser, the browser will send a request to a computer owned by Google, and there is a http sever run in that computer. The http server will get this request, and send a html page back to browser, so that your browser could display a Google website.
How does it Work
Here comes the job of backend software engineer.
The data your browser received are usually divided into two parts.
The first one is about how to organize page elements and how they interreact with each other. This part is developed by frontend, responsible for the graphical user interface.
The second is the content data. Backend is responsible for developing the data management process and provide the data.
Backend will provide the data by a backend server application. The flow is this.
| browser | ----page request----> | http server |
|browser | <----page response--- | http server |
| browser | ----content req------> | backend server |
| browser | <----content resp----- | backend server |
For example, when open Google, the page returned by http server contain the layout data as well as how to send request to backend. After user type in some keyword and click search button, a search request will be sent to backend server, and the backend server will execute the search process and return the search result. Meanwhile the backend may save this search request, so that next time you open Google, you will find search history there.
In short, the backend will Create, Read, Update, or Delete content data. This is why backend is known as CRUD engineer.
There are two aspect in backend jobs.
The first one is what the content data is. It is highly related with business. Let's go back to the Google example. The search result is the most important data. Besides that, there are all kinds of other data need to handle, like search history, search result usage, ads, user account, user behavior.
The second is how to process the data. Different content need different process. The search result need to be updated when website changes, and to be created when new website established, and to be read when user send search request. The search history need to be created when send new search request, and to be read when user send query search history request, but it do not require an update operation.
Understanding this two basic concept, then you could start building your own daemon server.
Daemon Server
Let's build something like a Google Analytics and we want to implement one of the features, browse count.
In the beginning, we should breakdown our goal from a backend perspective.
The content we are handling is a count number. In most cases, we need browse count for different pages. But let's make a most simplest daemon, all the content is a single number, indicating the browse count.
The process on this number will include: 1) increase one when a new browse event; 2) read the number.
I believe we are very closed to finish the design. The last piece of the puzzle is how do we maintain the number and implement the operation.
Usually we will store the data in dedicated database, but to simplify, let's just store it into a local file.
It is very clear how to implement the process.
About increasing one, we read number in the file, increase one, and store back.
About reading the number, just read it from the file.
I will put an example code here.
from http.server import BaseHTTPRequestHandler, HTTPServer import json import os
class BrowseCounter: def __init__(self, file_path='browse_count.txt'): self.file_path = file_path
# Initialize the file with 0 if it doesn't exist if not os.path.exists(self.file_path): with open(self.file_path, 'w') as file: file.write('0')
def _read_count(self): """Read the current count from the file.""" with open(self.file_path, 'r') as file: return int(file.read().strip())
def _write_count(self, count): """Write the updated count to the file.""" with open(self.file_path, 'w') as file: file.write(str(count))
def increase_count(self): """Increase the browse count by 1.""" count = self._read_count() count += 1 self._write_count(count) return count
def get_count(self): """Get the current browse count.""" return self._read_count()
# Initialize the counter counter = BrowseCounter()
class BrowseCounterHandler(BaseHTTPRequestHandler): def _send_response(self, status_code, data): """Send JSON response.""" self.send_response(status_code) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write(json.dumps(data).encode('utf-8'))
def do_GET(self): """Handle GET requests.""" if self.path == '/count': # Return the current count count = counter.get_count() self._send_response(200, {'count': count, 'message': 'Browse count retrieved successfully.'}) elif self.path == '/increase': # Increase the browse count new_count = counter.increase_count() self._send_response(200, {'count': new_count, 'message': 'Browse count increased successfully.'}) else: self._send_response(404, {'error': 'Not Found'})
def run_server(): """Run the HTTP server.""" server_address = ('localhost', 8080) httpd = HTTPServer(server_address, BrowseCounterHandler) print("Server started at http://localhost:8080") httpd.serve_forever()
if __name__ == "__main__": run_server() |
(rendered code may have indent issue, adjust indent accordingly)
You will need basic coding knowledge to understand it. Class BrowseCounter is responsible for maintain the count data. Class BrowseCounterHandler is responsible for handle http request.
You could install a python3 in Microsoft store or Apple store. And then run python file_name , the server will start listen on localhost:8080 .
After running, you could open http://localhost:8080/count in browser, you should be able to see the count, and open http://localhost:8080/increase will increase the count by one.
There are some problems in this server implementation. But it doesn't matter, we can understand what we are doing as a backend software engineer.
In this path, we will encounter more complex content, and more complicated process. We will have to think of brilliant ways to solve the complicity, develop scalability, keep availability, and so on.
Thanks for reading, don't hesitant to follow other blog in this series if you are interested.