docs: discussions: Alice Engineering Comms: 2024-06-25T22:23:29+00:00

docs/discussions/alice_engineering_comms/0662/index.md

@@ -0,0 +1 @@
+# 2024-06-21 Engineering Logs

docs/discussions/alice_engineering_comms/0662/reply_0000.md

@@ -0,0 +1,22 @@
+- https://github.com/intel/cve-bin-tool/pull/4200
+  - Merged!
+    - 🛤️🛤️🛤️🛤️🛤️🛤️🛤️
+- https://github.com/intel/cve-bin-tool/pull/4207
+
+```python
+class EntryPoint(importlib.metadata.EntryPoint):
+    def load(self):
+        module = importlib.import_module(self.value.split(":", maxsplit=1)[0])
+        for name, cls in inspect.getmembers(module, predicate=inspect.isclass):
+            if issubclass(cls, Checker) and cls is not Checker:
+                return cls
+        raise ImportError(
+            f"Could not find a class deriving from cve_bin_tool.checkers.Checker in module: {module!r}"
+        )
+```
+
+- TODO
+  - [x] https://github.com/intel/cve-bin-tool/pull/4200
+  - [ ] [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/intel/dffml/badge)](https://scorecard.dev/viewer/?uri=github.com/intel/dffml)
+    - [ ] https://github.com/intel/dffml/issues/1583
+    - [x] `gh pr list --json url,author --jq '[.[] | select(.author.login == "app/dependabot")]`

docs/discussions/alice_engineering_comms/0662/reply_0001.md

@@ -0,0 +1,20 @@
+
+The best language for writing concurrent work queues depends on several factors, including the specific requirements of the project, the developer's familiarity with the language, performance needs, and the ecosystem of libraries and tools available. Here are a few languages that are commonly used for concurrency and might be suitable for implementing concurrent work queues:
+
+Go (Golang): Go is designed with concurrency in mind, featuring goroutines (lightweight threads managed by the Go runtime) and channels for communication. Its simplicity and built-in concurrency primitives make it a popular choice for concurrent applications, including work queues.
+
+Rust: Rust offers powerful concurrency features without sacrificing safety. Its ownership and borrowing system ensures that data races are caught at compile time, making it a great choice for writing concurrent code that is both efficient and reliable.
+
+Java: Java has a rich set of concurrency libraries, including the java.util.concurrent package, which provides high-level concurrency constructs like thread pools, blocking queues, and synchronizers. Java's long history in enterprise environments also means there's a wealth of knowledge and tools for building concurrent applications.
+
+C#: With the Task Parallel Library (TPL) and async/await features, C# simplifies writing concurrent and asynchronous code. It's a good choice for developers working within the .NET ecosystem.
+
+Python: While Python's Global Interpreter Lock (GIL) can be a limitation for CPU-bound tasks, it's still a popular choice for I/O-bound concurrency thanks to its asyncio library and frameworks like Celery for distributed task queues.
+
+Erlang/Elixir: Both Erlang and Elixir run on the BEAM virtual machine, which is designed for building scalable and fault-tolerant systems. They offer lightweight processes and message passing, which are ideal for concurrent work queues, especially in distributed systems.
+
+JavaScript (Node.js): Node.js is built around an event-driven, non-blocking I/O model, which makes it suitable for handling many concurrent connections. The async/await syntax in modern JavaScript simplifies writing asynchronous code.
+
+Scala: Scala, which runs on the JVM, offers powerful concurrency support through the Akka framework, which implements the actor model. This can be particularly useful for creating distributed work queues.
+
+Ultimately, the "best" language will depend on your specific use case, performance requirements, and developer expertise. It's important to evaluate the trade-offs and choose a language that aligns with your project's goals and the skills of your team.

docs/discussions/alice_engineering_comms/0663/index.md

@@ -0,0 +1 @@
+# 2024-06-22 Engineering Logs

docs/discussions/alice_engineering_comms/0663/reply_0000.md

@@ -0,0 +1,3 @@
+## 2024-06-22 @pdxjohnny Engineering Logs
+
+- https://github.com/intel/cve-bin-tool/pull/4207

docs/discussions/alice_engineering_comms/0663/reply_0001.md

@@ -0,0 +1 @@
+- https://github.com/daytonaio/daytona

docs/discussions/alice_engineering_comms/0663/reply_0002.md

@@ -0,0 +1,7 @@
+- git + SCITT policy engine as CI / local CI / federated local instance pre-check before federating aka running workflows
+
+```bash
+# Commit should check that you have a SCITT receipt for your CI run of the `r-c/` for this commit (release canidate of commit, CI / validation against this commit)
+# We should use DAG caching to determine commit ability, cannot commit unless CI has passed
+# This way we can only commit working code unless we use --expect-failures
+git commit --expect-failures