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