feat: 🎸 Support img display in mdx file

Author: xichen1

.DS_Store

@@ -5,4 +5,5 @@ date: "2021-07-24"
 description: "Another blog test test test"
 ---
 
-Here's another post! It's even better than the first one!
+Here's another post! It's even better than the first one!
+![Hopper The Rabbit](./icon.png)

blog/.DS_Store

@@ -0,0 +1,157 @@
+---
+title: "Database Design and Implementation Note"
+queryId: "database-design-and-implementation-note"
+date: "2021-10-09"
+description: "Notes for the book about database"
+tags: ["database", "note"]
+---
+
+
+
+In this post, I will record the notes when reading the book Database design and implementation (Sciore 2020). It mainly includes the points I feel important or unclear before reading the book. 
+
+The current version starts from chapter 2 since chapter 1 is more like the environment and conclusion   content. So let's start.
+
+## Chapter 2 JDBC
+
+### Concepts
+
+***Database engine:*** database engine is the software which manages(create, update, delete) the database directly. It is a part of DBSM.
+
+***Database client application:*** it is a software which calls the database engine's APIs to manipulate the database.
+
+***JDBC:*** it is a set of formats which regulates how to write database engine's APIs with Java. JDBC contains five interfaces: *Driver, Connection,Statement, ResultSet, and ResultSetMetadata*.
+
+Usually, the client application does not want to adapt to different format of engine API, instead it wants to use fixed APIs for several operations, like connecting to db, operating statement and receiving from database. So JDBC provides a regulation for all db engine - they must implement the interfaces to provide the required features.
+
+### Connect to database with JDBC
+
+The Driver interface in JDBC provides the method to connect client and database(connect). 
+
+It accepts the protocol of connection(who connects to who), location of the server(ip, path), and other arguments(authentication, create new or not).
+
+#### Vendor-specific code in client program
+
+Notice, even though JDBC provides the common format for all db engines, there is still vendor-specific command to call in JDBC client. The different db engines provide different Driver types, and to connect to server, the client must use those different Drivers. Also, when connecting to db, different engines require different connection string (to specify different configs). In this case, the Drive and the connection string in client may differ for different engines.
+
+Because of the different types of Driver, in client program, it needs to import the engine specified Driver class.
+
+#### Close a connection
+
+The connection class provides a method close() which allows to close the connection between client and server.
+
+### Exception Handle
+
+There are various exception might happen during running database, different db engine usually handle them in different ways. So to regulate the exception showing for client, JDBC provides a exception class ***SQLException***, it wraps the db engine's personal exception and provides the client a error message according to the wrapped exception.
+
+#### Try with resource syntax
+
+```kotlin
+try (Connection conn = d.connect(url, null)){
+
+} catch (SQLException e) {
+
+}
+```
+
+In this example, it creates a connection resource in try parentheses, when it reaches the end of try block, no matter it has a exception or finishing the execution, java will close the connection resource implicitly which avoids the resource leak.
+
+### Executing SQL statements
+
+After the connection is created, the connection class can use the method createStatement() to create a Statement object. The Statement has three basic methods -- 
+
+executeQuery, executeUpdate and close. 
+
+- executeQuery's argument is a double quoted SQL query, and returns a ResultSet object.
+
+- executeUpdate's argument is a double quoted SQL UPDATE query, and returns a ResultSet object.
+
+- executeUpdate method returns the number of records that were updated.
+
+- executeQuery method returns a ResultSet object which represents the output of the query.
+
+#### RestultSet
+
+It is a object used to store each row of the output after executing the SQL query. In the beginning it points to the position before the first row of output records. By calling the method  next(), it can move one row forward. When pointing to each, the client can use some methods to call that row's record. When next() method returns False, it's pointing to the end of the output records.
+
+```kotlin
+// connection
+String qry = "select ...";
+ResultSet rs = stmt.executeQuery(qry);
+while (rs.next()) {
+... // process the record
+    // getString(fieldName)
+    // getInt(fieldName)
+}
+```
+
+### ResultSetMetaData
+
+The interface ResultSetMetaData of JDBC can be used to record the information of each column (eg name, type, data size of each field in one table). It is the output of method `ResultSet.getMetaData();`
+
+```kotlin
+// i is the index of column, starting from 1
+// use a loop to get all columns' infor
+String name = md.getColumnName(i);
+int size = md.getColumnDisplaySize(i);
+int typecode = md.getColumnType(i);
+```
+
+### Whole process for a client to execute one SQL statement
+
+1. Accept one connection string from the input, determine it's connecting to server or Embedded by checking if there is "//" in connection string. Then create the proper Driver.
+2. Using the Driver to create a connection, by calling ` Driver.connect(connStr, null)` , and put this call in try statement to prevent the resource leak.
+3. Initializing a Statement object, to prepare for executing statement later.
+4. Inside the try block, using while loop to accept each line of statement, operating bases on the start str of the statement:
+   1. if starting with exit, close the connection, quit the process
+   2. if starting with "select"
+      1. Using the Statement object and query statement, calling ` stmt.executeQuery(SQLStatment)` and get the ResultSet object.
+      2. Using loop and proper methods to get each column's info(type, name, size)
+      3.  Using loop and ResultSet.next() to get each row's record.
+   3. if starting with other str
+      1. Using the Statement object and query statement, calling ` stmt.updateQuery(SQLStatment)`
+      2. Output how many records are updated
+
+### Transaction
+
+#### Autocommit or Not
+
+A Transaction is a set of work (SQL statements). When a set of work is completed successfully, the database engine will commit the change to the db. When any work inside the transaction fails, the engine will fail all work of this transaction and roll back the db's state.
+
+In the base JDBC implementation, the process implemented in a way called Autocommit, each statement is a transaction, so the engine will not commit multiple changes in one transaction. 
+
+This is reasonable since each transaction creates a lock which prevents the other transaction from committing, and executing one statement in each transaction will shorten the waiting time for the other transactions. But we may want the transaction to contain multiple work sometimes:
+
+1. When we need more than one statement active. For example, if we need the result of the first statement to operate the second statement. If we release the lock after executing the first statement, the result might be different when executing the second statement. So we need to lock the resource during the whole process of executing these two statements.
+
+2. When we need to execute more than one statement at the same time. For example, swapping two records:
+
+   ```sql
+   String cmd1 = "update SECTION set Prof= 'brando' where SectId = 43";
+   String cmd2 = "update SECTION set Prof= 'einstein' where SectId = 53";
+   ```
+
+   If we commit the db after the first stmt, two names will be same and this is an undesirable result.
+
+3. Because each stmt is independent, it might be inconvenient if we want to do a batch of work but it crashes in the middle of work. We have difficulty to determine which operations are successful and which failed. It's better to put them in one transaction and let them fail or succeed together.
+
+#### Solution
+
+To allow custom handle of commit/transaction, JDBC provides three APIs of Connection object for client.
+
+```kotlin
+public void setAutoCommit(boolean ac) throws SQLException;
+public void commit() throws SQLException;
+public void rollback() throws SQLException;
+```
+
+By calling ` setAutoCommit(False)`, it closes the engine's one stmt each transaction strategy, giving the client rights to decide when to commit or rollback. Then the client can decide the time to complete the transaction by itself.
+
+After all statements in one desired transaction is finished, the client can call commit(), and the client can call rollback() in catch block of the try statement of creating the connection, so that if any error happens, it can roll back the db.
+
+### Handle concurrency
+
+The concurrency in database is similar as it in operating system -- db engines handle the one transaction(process) first, stop it and move to handle another transaction(process), and move among different transactions. Similar as CPU, db engines cannot handle multiple transaction at the same time, instead, it stops one transaction, stores its states, and move to the other transactions. With the fast speed, it creates an illusion that it's handling multiple transaction at same time.
+
+This leads to problem, because if part of one transaction is finished, and another transaction start to executing the stmts, it will use the wrong, uncommitted records created by the first transaction.
+

blog/another-blog/icon.png

@@ -0,0 +1,81 @@
+---
+title: "Intro to Express"
+queryId: "intro-to-express"
+date: "2020-08-02"
+description: "My first touch with Nodejs and Express."
+tags: ["backend", "express", "introduction"]
+---
+
+### What is Express?
+
+Express is a Web framework based on node.js. It provides ways to recognize and respond to http request through Middleware and Router.
+
+### Start
+
+To start using Express, we need to import express and create one instance using express(). To test the application, we also need a port and use the instance to listen to the port. This port can replace the real root dir and simulate the root page of the application.
+
+```jsx
+const express = require('express')
+const app = express()
+const port = 3000
+
+app.listen(port, () => {
+  console.log(`Example app listening at http://localhost:${port}`)
+})
+```
+
+### Routing
+
+Routing is the way to determining the response to the particular request. A route needs one method (GET, POST, PUT), one path and one or more handler callback function(s). An example is:
+
+```jsx
+app.get('/', function(req, res))
+```
+
+The path represents the location of the request requires to change. The req object represents the HTTP request and res represents the HTTP response that the app will send when it receive a request.
+
+### Serving static files
+
+The work of the web application is the process of requests and responses. For example, when we open the main page of one web app, we send a request to GET index.html as a client. If such file is right in local dir, we can use express to get it directly as a static file. For example, if all our front-end file is in the dir path '~/build', we can use
+
+```jsx
+app.use(express.static('build'))
+```
+
+In this case, whenever the server receives the request to GET something, it will go to the build folder and look for the responded file. If there is no such file locally, Express will then go to the connected database to look for it through some condition (model schema).
+
+### Middleware
+
+Middleware functions are functions that have access to req, res and the 'next' function. There are five types of middleware. The next function can assign the direction of the flow. If the middleware does not end the req, res cycle, a next() function is required to continue the flow into the next middleware function.
+
+#### Application-level middleware
+
+This middleware includes two methods, app.use() and app.METHOD().
+
+If the app.use() only has one argument, the callback function, it will be executed every time the app receives a request. If there is the path in the arguments, the function will executed every time the app receives a request on the path.
+
+#### Router-level middleware
+
+The router middleware needs to be bound to an instance of "require('express').Router()". It can be seen as a middleware between app middleware and router. The RLM can only perform middleware and routing functions. After we bound the RLM to some routers, we can execute app.use(path, router_instance) and that will execute the corresponding method we bound to RLM instance.
+
+#### Error-handling middleware
+
+Whenever we catch some error in the middleware and route handlers, we need to pass the error to Express through next(error). The error will then be passed into the build-in error handler. We can also write error handlers and this is the error-handling middleware.
+
+```jsx
+app.use(function(err, req, res, next) {})
+```
+
+We can handle different errors inside the function, and in the end, we can continue to use next(error) to pass the error we cannot handle now to Express.
+
+### Handle unknown endpoints
+
+If the client send an request which is not defined in any middleware, we need to handle it by responding a 404. The way to handle writing and adding an unknown endpoint middleware after all app-level middleware and router-level middleware and before Error-handling middleware.
+
+```jsx
+app.use((request, response) => {
+    response.status(404).send({ error: 'unknown endpoint' })
+})
+```
+
+To learn more about Express, view [API reference](https://expressjs.com/en/5x/api.html).

blog/another-blog.mdx renamed to blog/another-blog/index.mdx

@@ -0,0 +1,91 @@
+---
+title: MIT 6.828 Lab 1 Note
+queryId: "mit-6828-lab1-note"
+date: "2020-12-22"
+description: "MIT OS course lab note"
+tags: ["operating system", "note"]
+---
+
+## Introduction
+
+From today, I am going to share my experience in learning, implementing labs of MIT 6.828 in my blog.
+
+My background knowledge includes: C, computer architecture, RISC-V.
+
+I am going to use 2018 version material simply because there are most amount of resource about this version online.
+
+[Course homepage](https://pdos.csail.mit.edu/6.828/2018/schedule.html)
+
+[lab1 page](https://pdos.csail.mit.edu/6.828/2018/labs/lab1/)
+
+## Environment setup
+
+First clone the course git repo, [Course Git reop](https://pdos.csail.mit.edu/6.828/2018/jos.git). Then install toolchain, [install instruction](https://pdos.csail.mit.edu/6.828/2018/tools.html). Note that if the Compiler Toolchain is already installed, the only thing needs to be installed is QEMU emulator. Next, lets compile the files in the Git repo.
+
+```bash
+sudo apt install gcc-multilib # if you are not under 32 bit environment
+cd lab
+make
+```
+
+Then type
+
+```bash
+make qemu
+```
+
+We will successfully start JOS in the QEMU emulator. Now we boot the template OS and finish the setup of environment and lets take a look at the memory distribution in 32-bit machine.
+
+## PC'S address space & PC start up process
+
+![PC's physical address](./pcmemory.png)
+
+The important part for PC start up is only the lower 1MB part, because right now CPU is under Real mode and the only accessible memory is this part. In this part, the most important on is BIOS (basic IO system), because code in BIOS starts the normal PC start up. And the other part of this 1MB memory is mapped by peripherals, which means CPU can read/write the other part to manipulate peripherals.
+
+#### An interesting history
+
+The max memory 32-bit processor can handle is 4GB. So when the 64-bit processor came out, larger memory were used in PC. The modern PC usually put BIOS at the top of the memory, and to keep the backward compatibility for some old software, designer keeps a "hole" from 0x000A0000 to 0x00100000.
+
+### Use GDB to analyze the process of start up
+
+Now open two terminals, move into the OS folder. In the first one, type
+
+```bash
+make qemu-nox-gdb
+```
+
+This line starts the emulator and waits for the connection of GDB. And in the second terminal, type
+
+```bash
+make gdb
+```
+
+This line starts GDB and connect it to the OS. The file .gdbinit configs GDB to debug the code executed in the boot of OS in QEMU.
+
+#### Very first instruction
+
+```bash
+[f000:fff0]    0xffff0:	ljmp   $0x3630,$0xf000e05b
+```
+
+This is the first line appears after we connect GDB and OS. It shows where does the processor fetch the very first instruction and what that instruction is when we boot a PC.
+
+Under the real mode, address is in the form of (segment base : offset). So in the above line, in [f000:fff0], 0xf000 is segment base and 0xfff0 is offset. For 0x3630, 0xf000e05b, 0x3630 is segment base and 0xf000e05b is offset. The way to transfer this form into physical form is:
+
+```plain
+phyAddr = 16 * segment + offset = 16 * CS + IP
+```
+
+And after translating, this line means the professor fetch instruction from address 0xFFFF0, and instruction inside is a jump instruction, and the target address is 0xF004 435B.
+
+So there is several natural questions:
+
+1. Why did the designer put the very first instruction in this location (distance between here and end of BIOS is 0x100000 - 0xFFFF0 = 16 bytes)?
+2. Why don't just put this instruction in the beginning of the BIOS?
+3. Considering it is a jump instruction, why not set the first instruction just at its target address?
+
+The first two questions can be answered together. We have to consider that each PC company has their own BIOS code, user can add BIOS code too. Also, different company designs different length of BIOS boot code, so if the user wants to add code, the place to add is uncertain. However, if instead, we put user created code in the beginning of BIOS, it is more convenient to manage. So normally we put BIOS boot code in the end of BIOS part.
+
+For the last question, because different PC has different length of BIOS boot code, for example, if this code is 1KB, the start address is 0x100000 - 0x400 = 0xFFC00. If the code is 2KB, the start address is 0xFF800. And it is not a good practice to adjust the first instruction address in each PC. So the rule is put a jump instruction at 0xFFFF0 and the target is defined by each company.
+
+## TO BE CONTINUE