updates

Signed-off-by: Raj Patil <rajp152k@gmail.com>

Content/20231215140912-type.org

@@ -14,9 +14,6 @@ It might be beneficial to structure entities into relevant categories when it co
 To be populated
 * Practical
 ** Schema
-:PROPERTIES:
-:ID:       e47e785a-60dc-4ee6-b0b3-7cd2fd75c863
-:END:
  - a type specification for records when it comes to working with [[id:2f67eca9-5076-4895-828f-de3655444ee2][a DataBase]]
  - also used more casually when talking about the representation specification of [[id:86de7485-e9c0-4b7f-9f11-adb8229afdf4][serialized data]]
 

Content/20240215121050-kubernetes.org

@@ -8,6 +8,8 @@
 see [[id:f822f8f6-89eb-4aa8-ac8f-fdcff3f06fb9][Orchestration]]
 
 * Stream
+** 0x2324
+ - see [[id:dd91e448-4e13-471f-aa2a-3137b420db91][kubeconfig]]
 ** 0x22E3
  - reading up on [[id:7cb8489b-2b84-4224-b3f9-9f5bf0f38cfe][autoscaling]]
  - see [[id:7f960631-c727-41b8-80c2-3ccaa4ae4ba2][Scheduling Algorithms]] & [[id:59305648-ed10-4298-be07-cd67f277f612][Scheduling-K8S]]

Content/20240423103301-actor_model_computation.org

@@ -4,7 +4,28 @@
 #+title: Actor-Model Computation
 #+filetags: :programming:
 
-* Relevant
+* Overview
+*** Overview of Actor-Model Computation
 
+- *Definition*: Actor-model computation is an abstraction used in computer science to model computation as a collection of "actors."
+- *Actors*: The fundamental units of computation in this model that encapsulate state and behavior, interact with each other through asynchronous message passing.
+- *Concurrency*: Supports concurrent computation by allowing actors to operate independently and in a non-blocking manner.
+- *Location Transparency*: Actors can communicate regardless of their physical location in a system, enabling distributed computing.
+- *Fault Tolerance*: The model encourages building systems that can gracefully handle failures by isolating actors.
+
+*** Key Concepts
+
+- *[[id:f10899df-3d45-4290-bc50-b75c85bfb66b][Message Passing]]*: Actors communicate by sending messages, ensuring that interactions are loosely coupled.
+- *State Management*: Each actor maintains its own state and is responsible for managing it, thus simplifying reasoning about state changes.
+- *Supervisor Hierarchy*: An organizational structure where actors can supervise other actors, enabling a robust fault recovery mechanism.
+
+*** Connections
+
+- The *actor model* contrasts with shared-state concurrency models, where threads share memory and require synchronization, leading to complexities like deadlocks and race conditions.
+- *Applications*: Widely used in systems requiring high concurrency, such as telecommunications (e.g., [[id:158b95bc-9434-48f2-b932-3be750afa7e6][Erlang]]), [[id:a3d0278d-d7b7-47d8-956d-838b79396da7][distributed systems]], and real-time applications.
+- It has influenced various programming languages and frameworks, promoting a paradigm centered on concurrency and parallelism, most notably in languages like [[id:9497fb82-9220-4e8d-b29c-9811c14a70ab][Scala]] and Akka.
+
+* Relevant Nodes
+** [[id:29c69e24-36df-4283-b8e7-1398f205f40f][Ergo]]
 * Resources
  - https://en.wikipedia.org/wiki/Actor_model

Content/20240707174313-plantuml.org

@@ -35,6 +35,9 @@ Note "1" *-- "*" Tag
 @enduml
 #+end_src
 
+#+RESULTS:
+[[file:images/plant-uml.png]]
+
 ** State diagrams
 
 #+begin_src plantuml :file images/plantuml-state.png :exports both
@@ -47,6 +50,9 @@ Review --> Publish: Share
 @enduml
 #+end_src
 
+#+RESULTS:
+[[file:images/plantuml-state.png]]
+
 ** Mind Maps
 #+begin_src plantuml :file images/plantuml-mmap.png :exports both
 @startmindmap

Content/20241215001526-erlang.org

@@ -0,0 +1,5 @@
+:PROPERTIES:
+:ID:       158b95bc-9434-48f2-b932-3be750afa7e6
+:END:
+#+title: Erlang
+#+filetags: :erlang:

Content/20241215001657-scala.org

@@ -0,0 +1,5 @@
+:PROPERTIES:
+:ID:       9497fb82-9220-4e8d-b29c-9811c14a70ab
+:END:
+#+title: Scala
+#+filetags: :scala:

Content/20241215002845-ergo.org

@@ -0,0 +1,10 @@
+:PROPERTIES:
+:ID:       29c69e24-36df-4283-b8e7-1398f205f40f
+:END:
+#+title: Ergo
+#+filetags: :erlang:golang:
+
+Exposing erlang ecosystem in golang
+
+* Resources
+ - https://docs.ergo.services/

Content/20241215003129-network_transparency.org

@@ -0,0 +1,23 @@
+:PROPERTIES:
+:ID:       9d903415-5198-4b13-b2e4-ef0acc99c76c
+:END:
+#+title: Network Transparency
+#+filetags: :network:
+
+* Overview
+
+- *Definition of Network Transparency*: Network transparency refers to the degree to which users can see and understand the workings of a [[id:a4e712e1-a233-4173-91fa-4e145bd68769][network]], including its [[id:11d303f1-d337-4f51-b211-db435a9f2cd0][protocols]], architecture, and interactions.
+
+- *Importance in Networking*:
+  - Facilitates [[id:20240218T063707.851290][trust]] among users.
+  - Enhances security by allowing for audits and assessments.
+  - Aids in problem detection and resolution.
+
+- *Key Aspects*:
+  - *Visibility*: Information on network operations and performance metrics should be easily accessible.
+  - *Accessibility*: Tools and data for monitoring should be user-friendly.
+  - *Interoperability*: Different systems and protocols must work together seamlessly, allowing users to understand how components interact.
+
+- *Applications*:
+  - Used in corporate networks for compliance and governance.
+  - Integral to [[id:20240519T201406.029955][blockchain]] technologies where transactions and operations are visible to all participants.

Content/20241215010104-idempotence.org

@@ -0,0 +1,33 @@
+:PROPERTIES:
+:ID:       d508997a-359b-4581-b781-b3e87e41fb23
+:END:
+#+title: Idempotence
+#+filetags: :math:
+
+* Overview
+
+- *Definition of Idempotence:*
+  - A property of certain operations or functions, where applying them multiple times does not change the result beyond the initial application.
+
+- *Computer Science Context:*
+  - In programming and [[id:20240101T073142.439145][APIs]], an idempotent operation can be performed multiple times without different outcomes.
+  - [[id:88828c6f-87e0-4569-b236-dc6ebb72d282][HTTP methods]] like PUT and DELETE are generally considered idempotent.
+
+- *Generalization in Algebra:*
+  - In a [[id:bb4cc157-483e-462b-b0a7-90617601c808][monoid]] (an algebraic structure), an element \( a \) is idempotent if \( a \cdot a = a \).
+
+- *Applications:*
+  - Database operations: Ensuring that commands like update do not result in multiple records being altered inadvertently.
+  - Functional programming: Enhancing code reliability and predictability by using idempotent functions.
+
+*Connections:*
+- The concept of idempotence bridges multiple fields, from mathematics and computer science to functional programming, emphasizing its foundational role in logical reasoning and system reliability.
+- Idempotence is crucial for designing systems that are fault-tolerant and predictable, allowing users to repeat actions without unintended effects.
+
+*Questions for Further Research:*
+- How does the concept of idempotence apply to distributed systems or APIs in real-world applications?
+- What are the implications of idempotence in database transactions, particularly in the context of ACID properties?
+- Are there any notable exceptions or edge cases in which an operation is considered idempotent in theory but not in practice?
+
+* Idempotence and [[id:3586cec4-d474-404e-87af-6e3520049494][Ephemerality]] in the [[id:739d8493-d7a6-4eee-b31a-44d087f4fb42][cloud native]] world
+ - https://www.appdynamics.com/blog/engineering/what-are-idempotency-ephemerality-in-cloud-native-world/

Content/20241215083421-monoid.org

@@ -0,0 +1,31 @@
+:PROPERTIES:
+:ID:       bb4cc157-483e-462b-b0a7-90617601c808
+:END:
+#+title: Monoid
+#+filetags: :math:
+
+* Overview
+*** Overview of Monoid
+
+- *Definition*: A monoid is an [[id:412f3aa9-2b5f-4e78-9b4e-1adfa34bfe01][algebraic structure]] consisting of a set equipped with an associative binary operation and an identity element.
+
+- *Components*:
+  - *Set*: A non-empty set \( M \).
+  - *Binary Operation*: A function \( \cdot : M \times M \rightarrow M \) representing the operation.
+  - *Associativity*: For all \( a, b, c \in M \), \( (a \cdot b) \cdot c = a \cdot (b \cdot c) \).
+  - *Identity Element*: There exists an element \( e \in M \) such that for all \( a \in M \), \( e \cdot a = a \cdot e = a \).
+
+- *Examples*:
+  - The set of natural numbers \( \mathbb{N}_0 \) (including zero) with addition as the operation.
+  - The set of strings over a fixed alphabet with string concatenation as the operation.
+
+- *Equivalent Notations*: Monoids can be notated using the triplet \( (M, \cdot, e) \), where \( M \) is the set, \( \cdot \) is the operation, and \( e \) is the identity element.
+
+*** Connections:
+
+- *Relation to [[id:8a045d3f-6bea-4844-94b5-3d59c51b042f][Groups]]*: Every monoid can be seen as a generalization of groups, where groups have the additional property of every element having an inverse.
+
+- *Applications*:
+  - Used in computer science, particularly in [[id:20231212T081907.908301][functional programming]] (e.g., fold operations).
+  - Helpful in category theory, where monoids can represent objects and morphisms.
+

Content/20241215083626-group_theory.org

@@ -0,0 +1,5 @@
+:PROPERTIES:
+:ID:       8a045d3f-6bea-4844-94b5-3d59c51b042f
+:END:
+#+title: Group Theory
+#+filetags: :math:

Content/20241215111312-ephemerality.org

@@ -0,0 +1,5 @@
+:PROPERTIES:
+:ID:       3586cec4-d474-404e-87af-6e3520049494
+:END:
+#+title: Ephemerality
+#+filetags: :meta:

Content/20241218100004-kubeconfig.org

@@ -0,0 +1,76 @@
+:PROPERTIES:
+:ID:       dd91e448-4e13-471f-aa2a-3137b420db91
+:END:
+#+title: kubeconfig
+#+filetags: :k8s:
+
+* Overview
+
+- *Kubeconfig*:
+  - A configuration file used by [[id:8fd3deca-b629-4df6-b22c-ff57cf8c028d][kubectl]], the command-line tool for interacting with [[id:c2072565-787a-4cea-9894-60fad254f61d][Kubernetes]] clusters.
+  - Typically located at =~/.kube/config= by default, but can be overridden by environment variables.
+
+- *Key Features*:
+  - *Clusters*: Defines the Kubernetes clusters to connect to, including server URLs and authentication information.
+  - *Contexts*: Allows users to define multiple contexts for different cluster configurations, including user and cluster associations.
+  - *Users*: Specifies the authentication credentials for connecting to the clusters, such as tokens, certificates, or username/password combinations.
+
+- *Structure*:
+  - Written in [[id:7cd81a80-dbc4-4c6e-860a-f05b14798e68][YAML]] format.
+  - Contains sections for clusters, contexts, users, and the current context in use.
+
+- *Use Cases*:
+  - Simplifies management of different Kubernetes environments (e.g., development, staging, production).
+  - Enables users to switch between clusters and authentication methods effortlessly.
+
+*** Connections Between Entities
+
+- The kubeconfig file's structure (clusters, contexts, users) facilitates efficient management by organizing information needed to communicate with various Kubernetes clusters.
+- By leveraging contexts within kubeconfig, users can easily switch environments, which is critical for developers working across multiple stages of deployment.
+- Authentication information under the user section directly ties into accessing resources in Kubernetes, making security a key consideration when configuring this file.
+
+*** Questions for Further Clarity
+- Are you looking to configure a kubeconfig file for a specific environment or use case?
+- Do you need guidance on best practices for managing multiple configurations?
+- Is there a particular issue or challenge you are facing with your current kubeconfig setup?
+
+*** Pathways for Further Research
+- What are the best practices for securing your kubeconfig file?
+- How can you automate kubeconfig management using CI/CD tools?
+- What are the implications of using multiple kubeconfig files in a dynamic environment?
+* Extracting the Config
+
+  - *Using =kubectl config view=*:
+    - Command: =kubectl config view --minify --flatten=
+      - =--minify=: Shows only the information related to the current context.
+      - =--flatten=: Combines the output into a single structure, making it easier to read and copy.
+
+  - *Exporting Environment Variables*:
+    - To pass the credentials and other settings as environment variables, you can use:
+      #+begin_src bash
+      export KUBECONFIG=~/.kube/config
+      #+end_src
+
+  - *Extracting Information for a Specific Context*:
+    - Command: =kubectl config get-contexts [CONTEXT_NAME]=
+      - Replace =[CONTEXT_NAME]= with the desired context name.
+
+  - *Copying Config to a New File*:
+    - Redirect output from =kubectl config view= to a new file:
+      #+begin_src bash
+      kubectl config view --minify --flatten > path/to/new-kubeconfig.yaml
+      #+end_src
+
+  - *Manual Extraction*:
+    - You may manually copy the relevant sections (clusters, users, and contexts) from the kubeconfig file, typically located at =~/.kube/config=.
+
+** Questions for Further Clarification
+- Do you need the configuration for a specific context or cluster?
+- Are you planning to share or deploy the extracted config in another environment?
+- Would you like to include or exclude any sensitive information from the extraction?
+
+** Pathways for Further Research
+- How can you manage and automate kubeconfig extraction in CI/CD pipelines?
+- What security measures are recommended when sharing kubeconfig files?
+- How can using tools like =kube-ps1= enhance the usability of your kubeconfig setup?
+* Resources

Content/20241218100154-kubectl.org

@@ -0,0 +1,5 @@
+:PROPERTIES:
+:ID:       8fd3deca-b629-4df6-b22c-ff57cf8c028d
+:END:
+#+title: kubectl
+#+filetags: :k8s:

Content/20241218184944-mcp.org

@@ -0,0 +1,15 @@
+:PROPERTIES:
+:ID:       f6f7f087-b7fe-4192-8950-497166f5af0f
+:END:
+#+title: MCP (Model Context Protocol)
+#+filetags: :network:ai:
+
+* Model Context Protocol
+
+* Relevant Tooling
+** CLI testing utilities
+ - https://github.com/mark3labs/mcphost
+ - https://github.com/otwld/ollama-helm
+
+* Resources
+  - https://modelcontextprotocol.io/introduction

Content/20241219104211-karpor.org

@@ -0,0 +1,14 @@
+:PROPERTIES:
+:ID:       b5c02b4f-4476-4af1-88ad-2ca1cd2aec8e
+:END:
+#+title: Karpor
+#+filetags: :open-source:project:
+
+* Work Logs
+** 0x2325
+ - init chronologically descending logs for karpor contribs
+ - [[id:f6f7f087-b7fe-4192-8950-497166f5af0f][model context proctol]] integration into the stack is what I'm going for
+* Relevance
+ - https://github.com/KusionStack/karpor/issues/658
+* Resources
+ - https://github.com/KusionStack/karpor