Theism vs. Atheism pros and cons

 

Optimization

 https://industri.fatek.unpatti.ac.id/wp-content/uploads/2019/03/116-A-Gentle-Introduction-to-Optimization-B.-Guenin-J.-K%C3%B6nemann-L.-Tun%C3%A7el-Edisi-1-2014.pdf

Concurrency

 https://www.reddit.com/r/rust/comments/11pgs04/trying_to_visualize_how_memory_ordering_and/

https://writings.stephenwolfram.com/2021/09/multicomputation-a-fourth-paradigm-for-theoretical-science/

https://www.wolframphysics.org/technical-introduction/the-updating-process-for-string-substitution-systems/foliations-and-coordinates-on-causal-graphs/

Konrad Zuse

 Interesting people

https://en.wikipedia.org/wiki/Konrad_Zuse 

Clocks

 There are two main problems to resolve: a) events needs to be totally ordered and b) detect concurrent events. Lamport timestamp addresses the total order problem; and vector clock helps to detect concurrent events.

 Lamport clocks: https://www.youtube.com/watch?app=desktop&v=cc3vjDHWYx8 , 

Masterminds of programming: Folks talking about why they designed certain programming languages

 https://www.amazon.com/dp/0596515170 

http://bobzhang.dscloud.me/Calibre%20Library/Biancuzzi%2C%20Federico_%20O%27Reilly/Masterminds%20of%20Programming%20%28197%29/Masterminds%20of%20Programming%20-%20Biancuzzi%2C%20Federico_%20O%27Reilly.pdf 

Primes and particles

 Recently i realized, that primes are similar to "elementary particles" of arithmetic i.e. other numbers can be constructed from primes but primes cannot be constructed from other numbers. 

In that regard, making a note of a paper i came across about how primes are related to the physical world

1. https://www.quantamagazine.org/a-chemist-shines-light-on-a-surprising-prime-number-pattern-20180514/ 
2. on Particles and Primes: https://arxiv.org/abs/1608.07175 . This paper is quite heavy but a good opportunity to introduce myself to the terminology outlined therein such as
1. associative normed division algebras C and H (ie C (the complex numbers); H (the quaternions).)

Philosophy of software design

 Liked this talk: https://www.youtube.com/watch?v=bmSAYlu0NcY 

Linux Network Virtualization

 https://www.ibm.com/cloud/blog/diagnosing-packet-loss-in-linux-network-virtualization-layers-part-2 

Terraform and Graphs

 https://www.youtube.com/watch?v=Ce3RNfRbdZ0#t=12m30s 

Kubernetes to solve computational biology problems

 https://uu.diva-portal.org/smash/get/diva2:1145028/FULLTEXT01.pdf 

Federation architectures for identity: Full mesh, hub & spoke, hub-spoke with centralized login

 Federation architectures for identity: https://wiki.geant.org/display/eduGAIN/Federation+Architectures 

CDN caches, Traffic classes and Footprint desriptors

CDN caches:

 https://groups.cs.umass.edu/ramesh/wp-content/uploads/sites/3/2019/12/Footprint-Descriptors-Theory-and-Practice-of-Cache-Provisioning-in-a-Global-CDN.pdf  

Intro to virtualization

high level intro into virtualization types: https://virtualizationreview.com/articles/2014/10/14/7-layer-virtualization-model.aspx 

Here is an intro to docker layers: https://windsock.io/explaining-docker-image-ids/  which in turn leads to a common but (as was unknown to me) mechanism called COW or copy-on-write. https://en.wikipedia.org/wiki/Copy-on-write 

Explorations into Type Theory

 Came across this https://ferenc.andrasek.hu/papersybprx/Stephen_Yablo_circularity_and_paradox.pdf 

which gave me the hint that if we are seeing a paradox, either a semantic one or a set-theoretic one, the problem lies in our language. Apparently if we describe it in a better language the paradox disappears, i.e. the confusion/fudge factor clears up. 

Also, this led to some exploration into how people view Category Theory https://math.stackexchange.com/questions/2522116/is-category-theory-more-abstract-than-set-theory-or-proof-theory and this was a good example. 

Apparently, this took me to a page ive looked at previously - which is this diagram. which seems to be an attempt by people to seek a theory of truth. 

Coverage vs. Functional/Requirement Testing

Here are some examples where Testing differs from Coverage testing. I am assuming that the term "Coverage" means Code Coverage branch/loop coverage both. In summary testing is of the following types viz. Functional(Feature/Requirement) Testing, Code Coverage Testing. 

• Overflows/Underflows of variables, for example the following function, coverage is just passing any values of a and b, not caring about how overflows for example if a*b > 32-bit, the return value is correct. 

int foo(int a, int b) {

                        return a * b ;

}

• Handling Exceptions from lower layers: For example say we have the following code, where the innerfoo function can throw exceptions. A 100% coverage which mocks the innerfoo function will still miss the cases which are not handled i.e. coverage will test whatever is written - but won't test if whatever is written is enough from the functionality pov. 

int foo() {

try {

  innerfoo();

} catch( ExceptionName e1 ) {

   // catch block

} catch( ExceptionName e2 ) {

   // catch block

} catch( ExceptionName eN ) {

   // catch block

}                         

                    } 

•  Coverage testing does not cover Range Testing, for example, 

int foo(int a) {

              int b = innerfoo(a); 

                        if (b < 100) {

                            //do something

                        } 

          } 

           in which case, while coverage will be 100% if we pass a value of a that returns a b 

           such that it goes in the if block. However, coverage testing will miss noting that the code for the

           else is missing and if b >= 100 then it is not clear that the function foo will do the right thing

In summary thus, Coverage does not check functional/requirements. 

• Testing Features vs. Testing code that is written/ Functional Testing/Feature Coverage/Requirement Coverage: Code coverage will cover all branches but it won't be able to find out how much of the code written actually matches what is desired from the feature i.e. if the feature is supposed to do X, Y, Z then the code does that is found out by feature testing - code coverage will only test if the testing is covering the written code. This is also called Functional Testing. 
• When people refer to the word "Unit Testing" it effectively means doing feature/requirement testing for the function. 
• When people refer to integration testing, it refers to unit-testing the unit-tests i.e. for example imagine there are 2 gears that are individually unit-tested but integration testing is unit testing the behavior of 2 gears locked-together. For example verifying that turning left gear anticlockwise will turn the right gear clockwise. In terms of code, coverage will verify the unit-testing of individual components but again as mentioned previously may not cover overflows/exceptions i.e. will verify whatever is written is fine in terms of code-logic and execution, but wont verify whatever is written is what we want! 

Philosophy of Networking

 https://networkologies.files.wordpress.com/2014/10/5-networkedmind.pdf is a way to look at the world from a "networking" pov :) . Not sure what it is, but posting this as a reminder for me to follow up

and a reminder to learn about "Object Oriented Philosophy"

On the Complexity of Crafting Crash-Consistent Applications

 https://research.cs.wisc.edu/adsl/Publications/alice-osdi14.pdf which is a comprehensive study of application level crash-consistency protocols built atop modern file systems.

Transactions vs. locks

 https://makandracards.com/makandra/31937-differences-between-transactions-and-locking

One good insight this gave me, and in retrospect I think i knew about this, but making a note nevertheless that - the purpose of a lock is to ensure that only 1 thread accesses a critical piece of code. Thus a lock is in it's essence a queue with threadids. 

Computer Security Models

https://en.wikipedia.org/wiki/Computer_security_model

Some myths of Maths

https://plus.maths.org/content/myths-maths-four-colour-theorem 
which took me to this video
https://youtu.be/fwtVlcO6s-Y

Systemd beginner tutorial

https://www.golinuxcloud.com/beginners-guide-systemd-tutorial-linux/

Mockito

http://blog.rseiler.at/2014/06/explanation-how-proxy-based-mock.html

TLS session reuse

https://vincent.bernat.ch/en/blog/2011-ssl-session-reuse-rfc5077

2 Phase commit and how could one design systems that do not need a 2 Phase commit

http://dbmsmusings.blogspot.com/2019/01/its-time-to-move-on-from-two-phase.html

Conway's law

https://en.wikipedia.org/wiki/Conway%27s_law

Network Interfaces

http://cyberjedizen.blogspot.com/2018/03/ifconfig-output-on-macos-high-sierra.html

Network Isolation of Namespaces

First, here is a quick intro to namespaces. Note that namespaces and cgroups are orthogonal by design.

- Historical discussions
https://lwn.net/Articles/219794/  (2007)
https://lwn.net/Articles/531114/ (2013)

- Modern descriptions:
 https://jvns.ca/blog/2016/10/10/what-even-is-a-container/, and then newer discussion on network namespaces on linux: https://blog.scottlowe.org/2013/09/04/introducing-linux-network-namespaces/
"Each network namespace is a logically a separate networking stack, with separate addresses, separate firewall rules, separate qos policies etc.

Network devices and sockets belong to a particular network namespace and everything else figures out which network namespace you are talking about from the socket or network device."

This has nothing to do with systemd etc.
in this picture we created 3 pairs

• ns1_veth0, globalns_veth1 (1st pair)
• ns2_veth0, globalns_veth2 (2nd pair)
• ns1_veth1, ns2_veth1 (3rd pair)

Originally all pairs exist in the default/global namespace, and we can assign them to different namespaces so that the picture looks like this:

https://etherarp.net/network-isolation-of-services-with-systemd/

SSH Tunnels

https://www.tunnelsup.com/how-to-create-ssh-tunnels/ 

Infra Layers

Got this picture from https://www.theregister.co.uk/2017/12/06/what_is_terraform/, and it was enjoyable for me to see how I moved from the layer above (@Uber) to a layer below (@OCI)

PID namespaces

https://hackernoon.com/the-curious-case-of-pid-namespaces-1ce86b6bc900

Fielding Dissertation

https://www.ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm

Processes on Linux

Process ID Description:
0 The Scheduler
1 The init process
2 kflushd
3 kupdate
4 kpiod
5 kswapd
6 mdrecoveryd

(https://unix.stackexchange.com/questions/83322/which-process-has-pid-0) 

Linux Networking

I got this picture from https://epickrram.blogspot.com/2016/05/navigating-linux-kernel-network-stack.html?m=0, and the idea is that this is how the interaction between the network card and the driver running on on the CPU (in the interrupt handler?) works. The kernel module copies into a buffer called skbuff, which looks like this:
https://opensourceforu.com/2016/10/network-performance-monitoring/ and the kernel populates (copies) the data into the sk_buff data structure which look like this:

Go to this link for some deep dive on Raw sockets: https://packetstormsecurity.com/files/72743/SOCK_RAW-Demystified.html

Virtual switching technologies and Linux bridge

https://events.static.linuxfound.org/sites/events/files/slides/LinuxConJapan2014_makita_0.pdf

Schema evolution in Thrift, Protobuf and Avro

http://martin.kleppmann.com/2012/12/05/schema-evolution-in-avro-protocol-buffers-thrift.html

How do MTU affect network flow

https://networkdirection.net/articles/network-theory/mtu-and-mss/

A compilation of software anti-patterns

1. Lingusitic anti-patterns - functions were names wrong/improperly http://www.ptidej.net/publications/documents/CSMR13d.doc.pdf
2. Architecture anti-patterns: http://www.se.rit.edu/~swen-440/slides/instructor-specific/Kuehl/Lecture%2018.1%20Architecture%20Antipatterns.pdf 

Concurrency Control

Paraphrasing https://vladmihalcea.com/how-does-mvcc-multi-version-concurrency-control-work/

In Concurrency Control theory, there are two ways you can deal with conflicts:

• You can avoid them, by employing a pessimistic locking mechanism (e.g. Read/Write locks, Two-Phase Locking)
• You can allow conflicts to occur, but you need to detect them using an optimistic locking mechanism (e.g. logical clock, MVCC) - this is essentially that same concept of "tokens" I was previously exposed to in the context of distributed locks. 
• 

Java

Some links that I am collecting to understand Java better.

• Understanding JVM architecture https://medium.com/platform-engineer/understanding-jvm-architecture-22c0ddf09722
• Understanding JNI : https://docs.oracle.com/javase/9/docs/specs/jni/index.html (this is needed to understand how Java implements threads )
• Java Threads vs. Pthreads https://medium.com/@unmeshvjoshi/how-java-thread-maps-to-os-thread-e280a9fb2e06

Some dependency injection frameworks

• Guice: I liked this quick video which shows the basic ideas of Guice - modules and "injecting" dependencies into the global map of sorts using BIND, so that later we can use the appropriate class as needed. https://www.youtube.com/watch?v=fe1n8VIXZ-k 

Build Tools:

• https://technologyconversations.com/2014/06/18/build-tools/ Ant vs. Maven vs. Gradle

Types of Models

There are 3 types of models that we do (ref: http://www.problemistics.org/courseware/toolbook/modelling.html)

1. Iconic
2. Analog
3. Symbolic
1. mathematical
2. logical 
3. adhoc

What was interesting for me here is that so far, I have looked upon models as Icons connected by symbolic logic e.g. via rules of logical inference (based on Set theory)

Interesting Personalities in Distributed Systems and Netwoking

I grew up not much interested in Science and Mathematics but my interest in those fields was piqued by a famous personality by the name Richard Feynman by reading the book : "Surely you are joking Mr. Feynman". This book somehow made me realize that mathematics and physics can be fun !

Similarly my interest in the fields of Signal processing, and computational theory and algorithms was guided by my teacher during undergrad. (Udayan Kanade), and subsequently I got interested in Computer Architecture, Video Encoding, Video Streaming, Algorithms, Optimization, Game Theory etc.

Over years, I have been trying to find out similar personalities that would get me interested in the fields of Networking and Distributed Systems. Here are some colorful personalities in the field of distributed Systems
(1) https://martin.kleppmann.com/ 

Types of cache

Quick reminder about the 2 types of cache
(1) Lookaside Cache (note how Memcache uses the concept of Lease)
(2) Inline/Write through cache. (TAO is an example of a read-through, write-through cache)

https://blog.the-pans.com/different-ways-of-caching-in-distributed-system/

Measures of developer productivity

The most used metrics are

1. lines of code (LOC) per unit time (Delorey, Knutson, & Chun, 2007; Maxwell, Van Wassenhove, & Dutta, Oct 1996) 
2. Function points per unit time (Delorey et al., 2007; Maxwell & Forselius, 2000).
3. Number of diffs landed per unit time (Facebook, Uber)

Cloud Connectivity Patterns

https://blogs.oracle.com/cloud-platform/cloud-to-on-premise-connectivity-patterns-v2

Postgres internals

http://www.interdb.jp/pg/

Finding out what the world is working on

Came across this link : https://stackify.com/popular-programming-languages-2018/ which pointed me to these two links

1. https://www.tiobe.com/tiobe-index/ the languages that are popular today
2. https://octoverse.github.com/projects the projects that are popular today. 

Golang tools

Dependency management tools such as Godep, Sltr, etc.

Go’s templating language

Go’s code generation tools, such as Stringer

Popular Go web frameworks, such as Revel

Router packages, such as Gorilla Mux

Godoc comments

istio blogs

https://hackernoon.com/distributed-tracing-with-envoy-service-mesh-jaeger-c365b6191592

Software Engineering Blog posts

1. Paul Graham: http://www.paulgraham.com/ambitious.html
2. Joel https://www.joelonsoftware.com/

Crypto Notes

https://wanguolin.github.io/assets/cryptography_and_network_security.pdf
GF(2^n) and it's use in AES: https://engineering.purdue.edu/kak/compsec/NewLectures/Lecture7.pdf (and uploading the pdf to my google drive, in case it goes missing in the future from the Purdue link)

Kubernetes Notes

1. Getting Started: https://kubernetes.io/
2. Cloud Native Computing Foundation:  https://www.cncf.io/
3. Course to learn Kubernetes: https://courses.edx.org/courses/course-v1:LinuxFoundationX+LFS158x+2T2019/course/. As a first step install the software called Minikube ( see Instructions here: https://kubernetes.io/docs/setup/learning-environment/minikube/), as a part of which you will need to install kubectl 

Install go 1.12 (google for it), then clone kubernetes source code from git. We will start navigating the code base using the kubectl command, use the following to build kubectl e.g. on my mac

$ make WHAT='cmd/kubectl'

+++ [1014 17:55:59] Building go targets for darwin/amd64:
    cmd/kubectl 

which shows up in the output directory as :

./_output/local/go/bin/kubectl
./_output/local/bin/darwin/amd64/kubectl 

To look at the source code ; go to the directory cmd; you will see the following files that have an entrypoint main defined, which points out all the different things that the kubernetes product is built out of.

• clicheck/check_cli_conventions.go:func main() {
• cloud-controller-manager/controller-manager.go:func main() {
• gendocs/gen_kubectl_docs.go:func main() {
• genkubedocs/gen_kube_docs.go:func main() {
• genman/gen_kube_man.go:func main() {
• genswaggertypedocs/swagger_type_docs.go:func main() {
• genyaml/gen_kubectl_yaml.go:func main() {
• hyperkube/main.go:func main() {
• importverifier/importverifier.go:func main() {
• kube-apiserver/apiserver.go:func main() {
• kube-controller-manager/controller-manager.go:func main() {
• kube-proxy/proxy.go:func main() {
• kube-scheduler/scheduler.go:func main() {
• kubeadm/kubeadm.go:func main() {
• kubectl/kubectl.go:func main() {
• kubelet/kubelet.go:func main() {
• kubemark/hollow-node.go:func main() {
• linkcheck/links.go:func main() {
• preferredimports/preferredimports.go:func main() {
• verifydependencies/verifydependencies.go:func main() {

 

iptables / netfilter on linux

Have a look at this picture for how iptables works. Importantly note https://danielmiessler.com/study/iptables/: its made up of tables, chains and targets.
the flow http://xkr47.outerspace.dyndns.org/netfilter/packet_flow/


ref: https://www.youtube.com/watch?v=iP8YWcvKDr0

Language release history

https://golang.org/doc/devel/release.html

Tcp timeouts

https://blog.cloudflare.com/when-tcp-sockets-refuse-to-die/amp/

Thread local storage

This is a good pictorial representation of how linux stores thread local storage, and how it can be accessed using the key used in pthread_setspecific (each thread uses the key to find out its local thread local storage block) e.g. http://weng-blog.com/2016/07/Linux-tls/

how to become a good programmer

I liked this advice.
Write code 3 times !
(https://www.javaworld.com/article/2072651/becoming-a-great-programmer--use-your-trash-can.html) 

Embedded C++

RTTI, dynamic memory allocation and exceptions are among the most hotly debated subjects in embedded circles. (ref: http://forums.codeguru.com/showthread.php?539611-I-have-7-days-to-prepare-for-an-Embedded-C-Interview-Any-tips-and-good-links)

RTTI is used by dynamic_cast to figure out if a base ptr can be reinterpreted as a derived class ptr . look at https://blog.feabhas.com/2013/09/casting-what-could-possibly-go-wrong/

Also look at this https://cs.nyu.edu/courses/fall16/CSCI-UA.0470-001/slides/MemoryLayoutMultipleInheritance.pdf for description about virtual inheritance and memory layouts therein.

ipfs

Aim is to replace HTTP
https://ipfs.io/

Further, when reading about IPFs i came across Merkle trees, which are incidentally also used in Git to reduce the time for finding out what has changed between 2 branches.

This further took me to this paper : https://people.csail.mit.edu/silvio/Selected%20Scientific%20Papers/Zero%20Knowledge/Zero-Knowledge_Sets.pdf, 

How facebook scaled up memcached

https://www.facebook.com/notes/facebook-engineering/scaling-memcached-at-facebook/39391378919/
https://www.usenix.org/system/files/conference/nsdi13/nsdi13-final170_update.pdf

Memcached is available on github at https://github.com/memcached/memcached

Ref: https://medium.com/@SkyscannerEng/journey-to-the-centre-of-memcached-b239076e678a and picture from there:

Another reference is https://medium.com/@Alibaba_Cloud/redis-vs-memcached-in-memory-data-storage-systems-3395279b0941,

Thrift

https://github.com/apache/thrift 

Containers from scratch

Things to explore further:https://ericchiang.github.io/post/containers-from-scratch/
(1) chroot, and it does not have private namespaces
(1) creating "namespaces" with unshare
(2) entering namspace with nsenter
(3) network namesapces can be shared e.g. across containers.
(4) cgroup directories can be created in /sys/fs/cgroups, and then appropriate values configured. cgroups is a way for the kernel to have "controlled isolation"

Why BGP is a better iGP

https://archive.nanog.org/meetings/nanog55/presentations/Monday/Lapukhov.pdf and the RFC is https://tools.ietf.org/html/draft-ietf-rtgwg-bgp-routing-large-dc-01

Note that normally, when BGP RIBs are exchanged by two routers, if both sit in the same AS, then while their RIB will show the path, it will be marked with an "i", and that path will not be advertised to the outside world. If we instead give an AS to each rack and then use BGP it can be still made to work because each ASN is considered a private ASN. 

Distributed Systems: Compute Infra.

Google's paper about Borg: https://storage.googleapis.com/pub-tools-public-publication-data/pdf/43438.pdf


https://ericchiang.github.io/post/containers-from-scratch/

Job scheduling in Mesos and Kubernetes

https://stackoverflow.com/questions/44130725/differences-in-scheduling-between-mesos-and-kubernetes (which points to https://medium.com/@ArmandGrillet/comparison-of-container-schedulers-c427f4f7421)

and
https://stackoverflow.com/questions/43076831/dcos-cluster-resource-allocation-is-np-hard/43448790#43448790 (which suggests that Mesosphere Marathon uses first-fit bin packing algorithm)

Compute Platform comparison

I liked this comparison of platforms of (a) Virutalized compute resources vs. CaaS (taken from https://thenewstack.io/container-orchestration-scheduling-herding-computational-cattle/). In general modern cloud can be divided into
 Infrastructure as a Service (IaaS), Containers as a Service (CaaS), and Platform as a Service (PaaS).

Messaging patterns in ZeroMQ

As outlined here http://www.aosabook.org/en/zeromq.html, one can look upon all messaging to fall in these categories

1. Publish/Subscribe
2. Synchronous Request/Reply
3. Asynchronous Request/Reply
4. Push/Pull
5. Parallelised pipeline 

Refer to https://blog.scottlogic.com/2015/03/20/ZeroMQ-Quick-Intro.html for how this is used . The idea is to have "smart endpoint, dumb network", unlike Kafka which is a "dumb endpoint, smart network" model. The clients essentially connect to the server, and the server communicates to the clients based on the above messaging modes. Note that the clients and server can both be on the same machine (IPC) or even different threads in a process talking via an "endpoint" etc. 

Twitter Infra

https://blog.twitter.com/engineering/en_us/topics/infrastructure/2017/the-infrastructure-behind-twitter-scale.html

Periscope infra:

(from https://qr.ae/TWrUa5 ) and a video https://www.youtube.com/watch?v=xjC3ZKYG74g

1. Wowza Media Systems for streaming
2. PubNub for the chatroom
3. Circle CI and Travis CI
4. Fabric
5. Iron.io
6. Algoria for search and indexing
7. Slack

Scaling globally

There are 3 types of scalability issues that need to be addressed to scale to a global scale . Those are

1. Network scalability & service discovery. 
2. Compute scalability & virtualization
3. Storage scalability

One will see that organizations that offer cloud as a service use all three of these scalabilities.

Network Scalability :
(A) Load Balancers

Refer to this blog which points out how modern L4/L7 load balancers work. 

https://blog.envoyproxy.io/introduction-to-modern-network-load-balancing-and-proxying-a57f6ff80236 . I have also seen L3 load balancers used via DNS (e.g. UltraDNS sitebacker pools).
In summary I have seen load balancers of the following types:

• Proxy based load balancers

1. L3 load balancing: DNS based load balancing via pools (round-robin) or via mapping changes (Akamai), or via Anycast (See this for how BGP makes this happen: https://www.imperva.com/blog/how-anycast-works/) 
2. L4 load balancing via HAProxy (SSL termination via NGINX)
3. L7 load balancing via HAProxy and a sidecar like Muttley (Uber) , which is essentially based on Healthchecks, Traffic controller rules, and Zookeeper nodes that are maintained at a /zone/service/ level , and updated when a particular service is deployed to a machine.

• Client side load balancers:

1. GRPC based load balancing is an example of client-based load balancing.  Refer to https://github.com/grpc/grpc/blob/master/doc/load-balancing.md. (I believe this could be done using something like a muttley sidecar too) 

(B) Service discovery :

When a service is deployed on a machine, it needs to be discoverable. This can be done in the following ways

1. DNS based service discovery such as Mesos-DNS 
2. DNS based service discovery using SRV records (See this https://docs.citrix.com/en-us/citrix-adc/13/dns/service-discovery-using-dns-srv-records.html) 
3. Zookeeper based service discovery

Storage Scalability:
Refer to http://www.cloudbus.org/reports/DistributedStorageTaxonomy.pdf for a taxonomy of Distributed Storage Systems (DSS)
In summary, Distributed storage can be looked at from different perspectives. If we look at it from the point of view of "functionality" there is the following categorization:

1. Archival: Provide persistent nonvolatile storage. Achieving reliability, even in the event of failure, supersedes all other objectives and data replication is a key instrument in achieving this
2. General purpose Filesystem: Persistent nonvolatile  POSIX compliant filesystem e.g. NFS, CODA, xFS, 
3. Publish/Share: More volatile, think peer-peer
4. Performance: Operate in parallel over a fast network, typically will stripe data e.g. Zebra, 
5. Federation middleware: Bring together various filesystems over a single API
6. Custom: GFS (combination of many of the things above

Example

1. DHT : Store the keys associated with a node in that node's DNS records (e.g. TXT record) and the node info is obtained via SRV record for that node (refer to : https://labs.spotify.com/2013/02/25/in-praise-of-boring-technology/)

Compute Scalability

There are 4 main categories of cluster workloads (ref: https://eng.uber.com/peloton/)

1. Stateless jobs
2. Stateful jobs
3. Batch jobs
4. Daemon jobs

The idea is to have these jobs scheduled diversely to a cluster. This is done using the tools such as Borg, YARN (slowly moving to Spark in the industry), Mesos and Kubernetes.

Turing completeness using Mov

Apparently, turing completeness can be created using a single x86 instruction which is the MOV command:

https://drive.google.com/open?id=1cbnCSdBmkjEGxoScn2VtcR7SiC8hc45x 

Type Systems in Computer programs

https://en.wikipedia.org/wiki/Type_system has good survey of the landscape. What I was looking for was duck typing (as happens in Golang)

An O(ND) Difference Algorithm and Its Variations

https://neil.fraser.name/writing/diff/myers.pdf  which is considered the best general purpose diff algorithm.  See this: https://github.com/google/diff-match-patch 

The unwritten laws of engineering

Came across this somewhat popular book of engineering - i may not fully agree with it, but it is definitely good advice on what it means to be a professional engineer. (http://rotorlab.tamu.edu/me489/README/2010%20ASME%20Unwritten_Laws_of_Enginering.pdf) 

Debugging makefiles

https://www.oreilly.com/openbook/make3/book/ch12.pdf

Git rebasing

https://www.atlassian.com/git/tutorials/merging-vs-rebasing liked this link. noting

Semantic versioning

https://semver.org/ A proposal to create some formalization around what the X.Y.Z terms mean in a version number and thus, make it clear as to which APIs are backwards compatible and which are not (APIs take in version number as an argument) 

Google Engineering Tools Blog

http://google-engtools.blogspot.com

Of particular interest to me was:
http://google-engtools.blogspot.com/2011/06/build-in-cloud-accessing-source-code.html 

Facebook Infra Overview

http://www.ece.lsu.edu/hpca-18/files/HPCA2012_Facebook_Keynote.pdf Liked this. Making a note.

Arguments against OOP

https://caseymuratori.com/blog_0015 "The fallacy of “object-oriented programming” is exactly that: that code is at all “object-oriented”. It isn’t. Code is procedurally oriented, and the “objects” are simply constructs that arise that allow procedures to be reused. So if you just let that happen instead of trying to force everything to work backwards, programming becomes immensely more pleasant."

SRE role

https://landing.google.com/sre/book/index.html 

HAProxy internals

http://www.haproxy.org/

Things to follow up on:
(1) How is zero copy done? Using the "splice" system call on Linux
(2) MRU memory allocator
(3) Accepting multiple accepts at the same time across different processing listening to different ports of course.
(4) Tree based storage e.g.making heavy use of the Elastic Binary Tree http://wtarreau.blogspot.com/2011/12/elastic-binary-trees-ebtree.html

Weak Diffie Hellman and logjam attack

https://weakdh.org/ and https://www.youtube.com/watch?v=z5LrjLz_Q50 

Design patterns in C++

https://github.com/JakubVojvoda/design-patterns-cpp  liked this. noted.

Factory pattern:
https://www.oodesign.com/factory-pattern.html 

Blog on machine learning

Came across what some people say as one of the best places to learn about machine learning. Making a note: https://colah.github.io/ 

Mobile Real-time video segmentation

Came across this blog from google about how they have managed to find out the background in a video. https://research.googleblog.com/2018/03/mobile-real-time-video-segmentation.html  is the the link to the google research paper about this and https://people.eecs.berkeley.edu/~jonlong/long_shelhamer_fcn.pdf  is the paper they have built upon. I have to look into this soon. Adding as a follow up. 

Cassandra Cookbook

https://github.com/sjtuhjh/appdocs/blob/master/BooksAndPapers/Cassandra/Cassandra%20High%20Performance%20Cookbook.pdf 

AI Magazine

https://www.aaai.org/ojs/index.php/aimagazine/index 

What got me interested in this is : https://www.quora.com/What-is-the-biggest-unresolved-problem-for-AI, which is the quest for a general purpose intelligence i.e. building systems that can help us come up with the next "theory of relativity", or think like a human etc. Today's AI is mostly focused on classification 

The set-theoretic multiverse

I came across this somewhat intriguing idea of a set theoretic multiverse. I want to try to find out the links between a set theoretical multiverse and logics. As i look at it, I see logic as a theory based on the rules of set theory to propagate labels such as truth/false. What I am curious about is whether if there are more than 1 foundational set theory - does that lead to many logics .

http://lumiere.ens.fr/~dbonnay/files/talks/hamkins.pdf 

Doxatic logic & types of reasoners

https://en.wikipedia.org/wiki/Doxastic_logic 
Something i read long time back when i read Smullyan's books, but making a note because i love it. His types of reasoners is beautiful :)

Types of reasoners[edit]

To demonstrate the properties of sets of beliefs, Raymond Smullyan defines the following types of reasoners:

• Accurate reasoner:^[1][2][3][4] An accurate reasoner never believes any false proposition. (modal axiom T)

${\displaystyle \forall p:{\mathcal {B}}p\to p}$

• Inaccurate reasoner:^[1][2][3][4] An inaccurate reasoner believes at least one false proposition.

${\displaystyle \exists p:\neg p\wedge {\mathcal {B}}p}$

• Conceited reasoner:^[1][4] A conceited reasoner believes his or her beliefs are never inaccurate.

${\displaystyle {\mathcal {B}}[\neg \exists p(\neg p\wedge {\mathcal {B}}p)]\quad {\text{or}}\quad {\mathcal {B}}[\forall p({\mathcal {B}}p\to p)]}$

A conceited reasoner with rationality of at least type 1 (see below) will necessarily lapse into inaccuracy.

• Consistent reasoner:^[1][2][3][4] A consistent reasoner never simultaneously believes a proposition and its negation. (modal axiom D)

${\displaystyle \neg \exists p:{\mathcal {B}}p\wedge {\mathcal {B}}\neg p\quad {\text{or}}\quad \forall p:{\mathcal {B}}p\to \neg {\mathcal {B}}\neg p}$

• Normal reasoner:^[1][2][3][4] A normal reasoner is one who, while believing ${\displaystyle p,}$ also believes he or she believes p (modal axiom 4).

${\displaystyle \forall p:{\mathcal {B}}p\to {\mathcal {BB}}p}$

• Peculiar reasoner:^[1][4] A peculiar reasoner believes proposition p while also believing he or she does not believe ${\displaystyle p.}$ Although a peculiar reasoner may seem like a strange psychological phenomenon (see Moore's paradox), a peculiar reasoner is necessarily inaccurate but not necessarily inconsistent.

${\displaystyle \exists p:{\mathcal {B}}p\wedge {\mathcal {B\neg B}}p}$

• Regular reasoner:^[1][2][3][4] A regular reasoner is one who, while believing ${\displaystyle p\to q}$, also believes ${\displaystyle {\mathcal {B}}p\to {\mathcal {B}}q}$.

${\displaystyle \forall p\forall q:{\mathcal {B}}(p\to q)\to {\mathcal {B}}({\mathcal {B}}p\to {\mathcal {B}}q)}$

• Reflexive reasoner:^[1][4] A reflexive reasoner is one for whom every proposition ${\displaystyle p}$ has some proposition ${\displaystyle q}$ such that the reasoner believes ${\displaystyle q\equiv ({\mathcal {B}}q\to p)}$.

${\displaystyle \forall p:\exists q{\mathcal {B}}(q\equiv ({\mathcal {B}}q\to p))}$

If a reflexive reasoner of type 4 [see below] believes ${\displaystyle {\mathcal {B}}p\to p}$, he or she will believe p. This is a parallelism of Löb's theorem for reasoners.

• Unstable reasoner:^[1][4] An unstable reasoner is one who believes that he or she believes some proposition, but in fact does not believe it. This is just as strange a psychological phenomenon as peculiarity; however, an unstable reasoner is not necessarily inconsistent.

${\displaystyle \exists p:{\mathcal {B}}{\mathcal {B}}p\wedge \neg {\mathcal {B}}p}$

• Stable reasoner:^[1][4] A stable reasoner is not unstable. That is, for every ${\displaystyle p,}$ if he or she believes ${\displaystyle {\mathcal {B}}p}$ then he or she believes ${\displaystyle p.}$ Note that stability is the converse of normality. We will say that a reasoner believes he or she is stable if for every proposition ${\displaystyle p,}$ he or she believes ${\displaystyle {\mathcal {B}}{\mathcal {B}}p\to {\mathcal {B}}p}$ (believing: "If I should ever believe that I believe ${\displaystyle p,}$ then I really will believe ${\displaystyle p}$").

${\displaystyle \forall p:{\mathcal {BB}}p\to {\mathcal {B}}p}$

• Modest reasoner:^[1][4] A modest reasoner is one for whom every believed proposition ${\displaystyle p}$, ${\displaystyle {\mathcal {B}}p\to p}$ only if he or she believes ${\displaystyle p}$. A modest reasoner never believes ${\displaystyle {\mathcal {B}}p\to p}$ unless he or she believes ${\displaystyle p}$. Any reflexive reasoner of type 4 is modest. (Löb's Theorem)

${\displaystyle \forall p:{\mathcal {B}}({\mathcal {B}}p\to p)\to {\mathcal {B}}p}$

• Queer reasoner:^[4] A queer reasoner is of type G and believes he or she is inconsistent—but is wrong in this belief.
• Timid reasoner:^[4] A timid reasoner does not believe ${\displaystyle p}$ [is "afraid to" believe ${\displaystyle p}$] if he or she believes ${\displaystyle {\mathcal {B}}p\to {\mathcal {B}}\bot }$