自我督促，看视频记录帖

为了防止自己变懒散（工作后的通病吧），开个帖记录视频学习，督促自己

2018.07.09
design tinder
https://www.youtube.com/watch?v=tndzLznxq40
system design还是很看知识广度和深度的
之前看这个小哥的consistent hashing觉得他一定很厉害，看完system design觉得确实懂很多

tinder basic functionality:
1. user profile
2. recommadation
3. match
4. chat

1. user profile
   store personal information and several pictures for one user

   how to store pictures:
      file vs blob (binary large object)
      file is better: cheaper, faster, content delivery network(CDN)
      table:  profile id + image id + file url
                                                                     |---------------> session service
client  <-- username + token --> gateway service   <-- --> profile service  --> db
                                                                      |------------->  image service  --> db
                                                                                                                |------> distributed file system
4. chat
    client-server communication protocol:  HTTP, not a good choice for chat app
    pear to pear protocol: no server/ client, all equal.  eg.: XMPP

2018.07.20
monolith vs microservice
https://www.youtube.com/watch?v=qYhRvH9tJKw
monolith:
Simple to develop. Simple to test. Simple to deploy. You just have to copy the packaged application to a server.
Simple to scale horizontally by running multiple copies behind a load balancer.
Good for small team.

when package and team go larger and larger, hard to maintain. Need to understand whole application.
The size of the application can slow down the start-up time.
You must redeploy the entire application on each update.
Impact of a change is usually not very well understood which leads to do extensive manual testing.
Continuous deployment is difficult.
Monolithic applications can also be difficult to scale when different modules have conflicting resource requirements.
Another problem with monolithic applications is reliability. Bug in any module (e.g. memory leak) can potentially bring down the entire process. Moreover, since all instances of the application are identical, that bug will impact the availability of the entire application.
Monolithic applications has a barrier to adopting new technologies. Since changes in frameworks or languages will affect an entire application it is extremely expensive in both time and cost.

microservice:
The idea is to split your application into a set of smaller, interconnected services instead of building a single monolithic application. Each microservice is a small application that has its own hexagonal architecture consisting of business logic along with various adapters.

t tackles the problem of complexity by decomposing application into a set of manageable services which are much faster to develop, and much easier to understand and maintain.
It enables each service to be developed independently by a team that is focused on that service.
It reduces barrier of adopting new technologies since the developers are free to choose whatever technologies make sense for their service and not bounded to the choices made at the start of the project.
Microservice architecture enables each microservice to be deployed independently. As a result, it makes continuous deployment possible for complex applications.


How uber changed from monolith to microservice
https://www.youtube.com/watch?v=Zed6udTPGro

2018. 06. 12
nosql database
https://www.youtube.com/watch?v=qI_g07C_Q5I


1. characteristics of nosql
    non-relational, schema-less, friendly to cluster, mostly open source

2. data model
  Aggregate-oriented (BASE)
   (1) Document :  mongoDB
   (2) Key-value:  redis, dynamo
   (3) column family: Hbase, Cassandra

   (4) graph  nodes and arches, query graph structures   (ACID)

3. cons
    difficult to do complicated query and organize data in different ways, useful for always query using the same key

4. consistency
   relational:  ACID, atomic, consistent, isolated, durable
   non-relational: BASE

   logical/ replication consistency

5. CAP Theorem
   Consistency + Availability + PartitionTolerance
   If your system is distributed and has network partition, you can only choose Consistency or Availability
   Not a binary choice, different level of choice, can be divided into different activities.

6. other important concepts need to learn
   eventual consistency, relaxing durability, quorums, read-your-write consistency

2018. 06. 11
Cassandra database
https://www.youtube.com/watch?v=B_HTdrTgGNs
不适合刚开始看的人，应该先fully understand sql 和 nosql 以及 dynamo，Bigtable的原理再来看Cassandra比较好

Two important papers on database: (read them!)
1. Dynamo : Amazon's High Available Key-Value Store, 2007
2. BigTable: A Distributed Storage System for Structured Data, 2006

paper on Cassandra :
Cassandra: A Decentralized Structured Storage System, 2008
1. distributed feature of Dynamo,
2. Data model and storage from BigTable

Fully replicated, fully distributed, no single point of failure
sequential I/O (other databases are random I/O)
partitioning,
key hashing,
replication factor,
virtual nodes,
coordinated reads,
consistency level:
   Set with every read and write
   One
   Quorum  51% replicas ACK
   local quorum  51% replicas ACK in local dc
   local one  read repair only in local dc
   two
   all -- all replicas ack, full consistency

query language: CQL

2018.06.12
detailed explanation of CAP and ACID, BASE
https://www.youtube.com/watch?v=6_UDWIRcc60

ACID: atomicity, consistency, Isolation, Durability
BASE: Basically availability, soft state, eventual consistency

They are designed for different business model

2018.06.12
consistent hashing
https://www.youtube.com/watch?v=zaRkONvyGr8

06.14.2018
https://www.youtube.com/watch?v=fJW65Wo7IHI&index=1&list=PLGLfVvz_LVvS5P7khyR4xDp7T9lCk9PgE
随便看了点ood，感觉工作一年在看这个没啥意思
but。。uml是cs出身都懂的吗。。我直到上个project才知道哎
果然基础太差

2018.07.01
java design pattern
https://www.youtube.com/watch?v=tDxnyop48mY&list=PLsyeobzWxl7r2ZX1fl-7CKnayxHJA_1ol
factory design pattern：
avoid exposure of initialization of objects

builder design pattern:
个人感觉已经被lombok project完全实现了。不知道其他公司用不用lombok

adapter design pattern:
比如某些功能已经在别的package实现了，不可更改，需要在自己的package 直接用，就写一个adapter class implement 自己package里的interface，import已经在外部实现的功能，override一些method

composite design pattern:
like a tree structure, some obejects are leaf node not containing other objects,  some are not and contains several other objects

楼主在学的后端数据库吗，可否加微信一起学 不懂讨论讨论

ob123 发表于 2018-7-11 07:46
楼主在学的后端数据库吗，可否加微信一起学 不懂讨论讨论

可以在本帖讨论，没必要加微信吧