Forem: Pull Review with Scott Beeker

From Legacy Rest to GPC - Vanguard-Go ⚔️

Pull Review with Scott Beeker — Wed, 14 May 2025 23:06:35 +0000

So what is Vanguard?

Vanguard is a powerful library for Go net/http servers that enables seamless transcoding between REST and RPC protocols. Whether you need to bridge the gap between gRPC, gRPC-Web, Connect, or REST, Vanguard has got you covered. With support for Google's HTTP transcoding options, it can effortlessly translate protocols using strongly typed Protobuf definitions.

Why Vanguard?

Vanguard offers a range of compelling use cases that make it an invaluable addition
to your services:

RESTful Transformation: By leveraging HTTP transcoding annotations, you can effortlessly
support REST clients. This feature is especially handy during the migration from a REST API
to a schema-driven RPC API. With the right annotations, your existing REST clients can
seamlessly access your API, even as you transition your server implementations to Protobuf
and RPC.
Efficiency and Code Generation: Unlike traditional approaches like gRPC-Gateway,
Vanguard operates efficiently within Go servers, compatible with various servers such as
Connect and gRPC.
It doesn't rely on extensive code generation, eliminating the need for additional code
generation steps. This flexibility ensures that your code can adapt dynamically, loading
service definitions from configuration, schema registries, or via
gRPC Server Reflection,
making it a perfect fit for proxies without the hassle of recompilation and redeployment
each time an RPC service schema changes.
Legacy Compatibility: The HTTP transcoding annotations also empower you to support
legacy REST API servers when clients are accustomed to using Protobuf RPC. This lets
you embrace RPC in specific teams, such as for web or mobile clients, without the
prerequisite of migrating all backend API services.
Seamless Protocol Bridging: If your organization is transitioning from gRPC to Connect,
Vanguard acts as a bridge between the protocols. This facilitates the use of your existing
gRPC service handlers with Connect clients, allowing you to smoothly adapt to Connect's
enhanced usability and inspectability with web browsers and mobile devices. No need to
overhaul your server handler logic before migrating clients to Connect.

To bridge a REST API to gRPC using the Vanguard library in Go, as provided by connectrpc/vanguard-go, you can leverage its ability to transcode between REST and RPC protocols seamlessly. This guide outlines the steps to set up a server that supports both REST and gRPC clients using Vanguard, based on the library’s capabilities described in the repository.

Prerequisites

Go: Ensure Go is installed (version compatible with the two most recent major releases, per the library’s support).
Protobuf: Install protoc and the necessary plugins (protoc-gen-go, protoc-gen-connect-go, protoc-gen-grpc-go).
Vanguard: Install the Vanguard library:

  go get connectrpc.com/vanguard

Step-by-Step Guide

1. Define Your Protobuf Schema

Create a .proto file to define your service and messages. Include Google’s HTTP transcoding annotations to map gRPC methods to RESTful endpoints. For example:

syntax = "proto3";
package example.v1;
import "google/api/annotations.proto";

service ExampleService {
  rpc GetItem(GetItemRequest) returns (Item) {
    option (google.api.http) = {
      get: "/v1/items/{id}"
    };
  }
  rpc CreateItem(CreateItemRequest) returns (Item) {
    option (google.api.http) = {
      post: "/v1/items"
      body: "*"
    };
  }
}

message GetItemRequest {
  string id = 1;
}
message CreateItemRequest {
  string name = 1;
}
message Item {
  string id = 1;
  string name = 2;
}

The (google.api.http) annotations map gRPC methods to REST paths and HTTP methods.
Save this as example.proto in a directory like proto/.

2. Generate Code

Compile the .proto file to generate Go code for gRPC, Connect, and REST handling:

protoc --go_out=. --go_opt=paths=source_relative \
       --connect-go_out=. --connect-go_opt=paths=source_relative \
       --grpc-go_out=. --grpc-go_opt=paths=source_relative \
       proto/example.proto

This generates:

gRPC service definitions.
Connect handlers for HTTP/1.1 compatibility.
Structs for messages.

3. Implement the Service

Create a Go server that implements the gRPC service. For example:

package main

import (
    "context"
    "log"
    "net/http"
    examplev1 "path/to/generated/example/v1"
    "connectrpc.com/connect"
)

type ExampleServer struct {
    examplev1connect.UnimplementedExampleServiceHandler
}

func (s *ExampleServer) GetItem(ctx context.Context, req *connect.Request[examplev1.GetItemRequest]) (*connect.Response[examplev1.Item], error) {
    // Fetch item logic (e.g., from a database).
    item := &examplev1.Item{Id: req.Msg.Id, Name: "Sample Item"}
    return connect.NewResponse(item), nil
}

func (s *ExampleServer) CreateItem(ctx context.Context, req *connect.Request[examplev1.CreateItemRequest]) (*connect.Response[examplev1.Item], error) {
    // Create item logic.
    item := &examplev1.Item{Id: "new-id", Name: req.Msg.Name}
    return connect.NewResponse(item), nil
}

This server implements the ExampleService with basic logic for GetItem and CreateItem.

4. Set Up Vanguard Transcoder

Use Vanguard to wrap the service handler, enabling REST and gRPC support. Here’s a complete main.go:

package main

import (
    "log"
    "net/http"
    "connectrpc.com/vanguard"
    examplev1 "path/to/generated/example/v1"
    examplev1connect "path/to/generated/example/v1/examplev1connect"
)

func main() {
    // Initialize the service implementation.
    svc := &ExampleServer{}

    // Create a Connect handler for the service.
    path, handler := examplev1connect.NewExampleServiceHandler(svc)

    // Create a Vanguard service to transcode REST and RPC.
    services := []*vanguard.Service{
        vanguard.NewService(path, handler),
    }

    // Initialize the Vanguard transcoder.
    transcoder, err := vanguard.NewTranscoder(services)
    if err != nil {
        log.Fatalf("Failed to create transcoder: %v", err)
    }

    // Set up HTTP server with Vanguard handler.
    mux := http.NewServeMux()
    mux.Handle("/", transcoder)

    // Start the server.
    log.Println("Server starting on :8080...")
    if err := http.ListenAndServe(":8080", mux); err != nil {
        log.Fatalf("Server failed: %v", err)
    }
}

Vanguard Service: vanguard.NewService wraps the Connect handler, using the generated path and handler.
Transcoder: vanguard.NewTranscoder creates a middleware-like handler that routes and transcodes requests between REST, gRPC, gRPC-Web, and Connect protocols.
The server listens on port 8080 and handles both REST and gRPC requests.

5. Test the API

REST Client (using curl):

  # GET request
  curl http://localhost:8080/v1/items/123
  # POST request
  curl -X POST http://localhost:8080/v1/items -d '{"name": "New Item"}' -H "Content-Type: application/json"

Vanguard transcodes these REST requests to gRPC calls using the HTTP annotations.

gRPC Client (using a Go client or grpcurl):

  grpcurl -plaintext localhost:8080 example.v1.ExampleService/GetItem -d '{"id": "123"}'

The server handles native gRPC requests directly.

6. Optional: Add Compression and Configuration

Vanguard supports compression (e.g., gzip) and custom options. To enable compression:

services := []*vanguard.Service{
    vanguard.NewService(path, handler, vanguard.WithCompression(vanguard.CompressionGzip)),
}

You can also configure timeouts or custom codecs if needed.

Key Features of Vanguard

RESTful Transformation: Supports REST clients by mapping gRPC methods to HTTP endpoints via annotations, ideal for migrating from REST to gRPC.
Protocol Bridging: Allows gRPC and Connect clients to coexist, useful during transitions.
Efficiency: Unlike gRPC-Gateway, Vanguard operates within the Go server, reducing overhead and eliminating external dependencies.
Legacy Support: Can proxy requests to legacy REST backends, enabling gradual migration.

Example Use Case

Suppose you’re migrating a REST API to gRPC. You can:

Define gRPC methods with HTTP annotations matching existing REST endpoints.
Use Vanguard to handle both REST and gRPC requests.
Gradually update clients to use gRPC while maintaining REST compatibility.

Troubleshooting

Schema Errors: Ensure the service path matches the Protobuf schema. Use vanguard.NewServiceWithSchema for dynamic schemas.
Content-Type Issues: REST requests must use application/json or compatible types. Vanguard validates this automatically.
Debugging: Enable logging or use tools like grpcurl to inspect requests.

Additional Resources

Vanguard README: Detailed examples and configuration options.
Connect Documentation: Learn more about Connect protocol and handlers.
Protobuf HTTP Annotations: Reference for mapping gRPC to REST.

This setup allows you to support both REST and gRPC clients with minimal changes to your server code, leveraging Vanguard’s transcoding capabilities for a smooth transition or hybrid API. _

Let's Connect!!

*Coding examples are AI generated.

Promise.all()

Pull Review with Scott Beeker — Tue, 21 Jan 2025 03:39:08 +0000

Here's an interesting article on using Promise.all().

Understanding `Promise.all()` in JavaScript

Promise.all() is a powerful method in JavaScript that allows developers to handle multiple asynchronous operations concurrently. This method takes an iterable (usually an array) of promises and returns a single promise that resolves when all the input promises have resolved or rejects if any of the promises fail. This guide will explore the functionality of Promise.all(), its syntax, behavior, and practical examples.

Syntax

The syntax for Promise.all() is straightforward:

Promise.all(iterable);

iterable: An array or other iterable object containing promises or values. Non-promise values are treated as resolved promises.

Return Value

The method returns a promise with the following behaviors:

If the iterable is empty, it resolves immediately with an empty array.
If all promises in the iterable are fulfilled, it resolves to an array of the fulfilled values, maintaining their order.
If any promise is rejected, it immediately rejects with the reason of the first rejected promise, ignoring all other promises' results.

Fulfillment and Rejection

Fulfillment: When all promises resolve successfully, Promise.all() returns an array of results in the same order as the input promises.
Rejection: If any promise is rejected, Promise.all() rejects immediately with the rejection reason of that promise.

Practical Examples

Example 1: Basic Usage

In this example, we create three promises that resolve after different timeouts:

const promise1 = new Promise((resolve) => setTimeout(() => resolve('One'), 1000));
const promise2 = new Promise((resolve) => setTimeout(() => resolve('Two'), 2000));
const promise3 = new Promise((resolve) => setTimeout(() => resolve('Three'), 3000));

Promise.all([promise1, promise2, promise3])
  .then(values => console.log(values)) // Output: ['One', 'Two', 'Three']
  .catch(error => console.error(error));

Here, Promise.all() waits for all three promises to resolve and logs their results as an array.

Example 2: Handling Mixed Values

You can also mix resolved values and promises:

const p1 = Promise.resolve(42);
const p2 = Promise.resolve('Hello');
const p3 = new Promise((resolve) => setTimeout(() => resolve('World'), 1000));

Promise.all([p1, p2, p3])
  .then(values => console.log(values)) // Output: [42, 'Hello', 'World']
  .catch(error => console.error(error));

In this case, p1 and p2 are resolved immediately while p3 resolves after one second.

Example 3: Rejection Handling

If one of the promises is rejected, Promise.all() will reject immediately:

const p1 = Promise.resolve(42);
const p2 = Promise.reject(new Error('Failed!'));
const p3 = new Promise((resolve) => setTimeout(() => resolve('This will not run'), 1000));

Promise.all([p1, p2, p3])
  .then(values => console.log(values))
  .catch(error => console.error(error.message)); // Output: 'Failed!'

Here, because p2 is rejected, the entire operation fails and logs the error message.

Use Cases for `Promise.all()`

Fetching Multiple Resources: When you need to fetch data from multiple APIs simultaneously and wait for all responses before proceeding.
Parallel Processing: Executing multiple independent tasks at once where their results are needed together.
Batch Operations: Performing batch updates or calculations where each operation can be done independently.

Conclusion

Promise.all() is a fundamental tool for managing multiple asynchronous operations in JavaScript. It simplifies code by allowing developers to wait for several promises to resolve before proceeding with further logic. However, it’s crucial to handle rejections properly since any single failure among the promises will cause the entire operation to fail. Understanding how to effectively use Promise.all() can lead to cleaner and more efficient asynchronous code.

Citations:
[1] https://www.geeksforgeeks.org/javascript-promise-all-method/
[2] https://stackoverflow.com/questions/42210200/adding-a-promise-to-promise-all
[3] https://www.w3schools.com/jsref/jsref_promise_all.asp
[4] https://www.freecodecamp.org/news/promise-all-in-javascript-with-example-6c8c5aea3e32/
[5] https://www.simplilearn.com/promise-in-javascript-article
[6] https://www.reddit.com/r/node/comments/argxni/alternative_to_promiseall/
[7] https://dev.to/swarnaliroy94/methods-of-promise-all-any-finally-o2e
[8] https://www.geeksforgeeks.org/javascript-promise/
[9] https://dmitripavlutin.com/promise-all/
[10] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all

Server Side Web Assembly - Exploring the Unknown

Pull Review with Scott Beeker — Sat, 18 Jan 2025 23:51:45 +0000

My research from web assembly on the server side show promising results.

Server-side WebAssembly (Wasm) is an emerging technology that allows developers to run WebAssembly modules on the server, expanding its use beyond traditional browser environments. This approach offers several advantages, including performance, portability, and security.

Key Advantages of Server-Side WebAssembly

Efficiency: WebAssembly is designed to be fast and compact, making it suitable for server applications where performance is critical [2][5].
Portability: Developers can package server-side logic into Wasm modules that can run consistently across various environments, reducing compatibility issues [2][4].
Language Interoperability: WebAssembly can be compiled from multiple programming languages, enabling the integration of components written in different languages [2][4].
Sandboxed Security: Wasm's sandboxing features enhance security by isolating modules from the host environment, which is crucial for applications handling sensitive data [2][4].

Use Cases

Server-side WebAssembly can be employed in various scenarios:

Plug-in Architectures: Applications can allow users to extend functionality with custom Wasm modules, which integrate seamlessly with the host application [2].
Server-Side Rendering (SSR): Frameworks can render HTML on the server using Wasm, improving performance for clients with slower devices or networks [3].
Microservices Architecture: Wasm supports a modular approach that combines benefits of both microservices and monolithic architectures, allowing efficient cross-module calls while maintaining memory isolation [6].

Challenges and Future Development

Despite its potential, server-side WebAssembly faces challenges in proving itself as a production-ready technology. Early adopters have begun implementing it, but broader adoption will require further development and support to address scalability and integration issues [6]. Additionally, the WebAssembly System Interface (WASI) aims to facilitate interactions between Wasm modules and the host environment, although it is still in early stages of development [4][6].

In summary, server-side WebAssembly presents a promising avenue for building efficient, secure, and portable applications. Its ability to run across different platforms while leveraging existing codebases makes it an attractive option for modern software development.

Citations:
[1] https://learn.microsoft.com/en-gb/aspnet/core/blazor/hosting-models?view=aspnetcore-9.0
[2] https://www.codecentric.de/wissens-hub/blog/plug-in-architectures-webassembly
[3] https://wasmedge.org/docs/develop/rust/ssr/
[4] https://atix.de/en/blog/webassembly-on-the-server-side-what-is-wasi/
[5] https://blog.nginx.org/blog/server-side-webassembly-nginx-unit
[6] https://www.techtarget.com/searchitoperations/news/366551352/Server-side-WebAssembly-takes-shape-but-faces-challenges
[7] https://www.manning.com/books/server-side-webassembly
[8] https://www.reddit.com/r/rust/comments/16u7tbc/serverside_webassembly_state/

Let's connect!
https://x.com/mescottbeeker
https://github.com/prosandmusic

scalability...

Pull Review with Scott Beeker — Sun, 29 Dec 2024 09:29:20 +0000

scalability is not just about adding more resources but also about designing your system to use those resources efficiently

Fediverse - The new sound of social networking

Pull Review with Scott Beeker — Sat, 28 Dec 2024 16:21:20 +0000

Join me on my #buildinpublic startup journey.

https://github.com/opensource-tunester
https://x.com/tunesterapp
https://threads.net/tunesterig

[Boost]

Pull Review with Scott Beeker — Mon, 16 Dec 2024 21:54:08 +0000

Mastering Rust's Lifetime System: A Guide to Memory Safety and Performance

Aarav Joshi ・ Dec 16

#programming #devto #rust #softwareengineering

Star for Star Github Repo Thread....

Pull Review with Scott Beeker — Tue, 10 Dec 2024 01:36:22 +0000

Please share your repo for a star or organization for a follow mine is below:

https://github.com/opensource-tunester

mondayvibes #networking #connect

[Boost]

Pull Review with Scott Beeker — Mon, 02 Dec 2024 12:56:52 +0000

GraphRAG vs LazyGraphRAG: Revolutionizing Retrieval-Augmented Generation

Pull Review with Scott Beeker — Fri, 29 Nov 2024 16:12:37 +0000

The following article is AI generated. Hope you guys enjoy!!

GraphRAG vs LazyGraphRAG: Revolutionizing Retrieval-Augmented Generation

In the rapidly evolving field of artificial intelligence, Microsoft has introduced two groundbreaking approaches to Retrieval-Augmented Generation (RAG): GraphRAG and its successor, LazyGraphRAG. Both technologies aim to enhance the quality and efficiency of information retrieval and generation, but they differ significantly in their methodologies and performance characteristics.

GraphRAG: The Pioneer

GraphRAG, introduced by Microsoft, combines graph-based techniques with RAG to improve the understanding and retrieval of information from large datasets. It uses Large Language Models (LLMs) to extract and describe entities and their relationships, creating a structured representation of unstructured text[1][2].

Key Features of GraphRAG:

Comprehensive data summarization
Hierarchical community structure
Effective for global queries
High-quality, in-depth analysis

However, GraphRAG's strengths come at a cost. The extensive use of LLMs for data indexing and summarization results in significant computational expenses and time requirements[1].

LazyGraphRAG: The Game-Changer

LazyGraphRAG, Microsoft's latest innovation, addresses the limitations of GraphRAG while maintaining its benefits. This "lazy" approach defers LLM use until query time, dramatically reducing upfront costs and increasing efficiency[1][3].

Key Innovations of LazyGraphRAG:

No prior summarization required
Minimal indexing costs
Iterative deepening search
Flexible relevance test budget

Performance Comparison

LazyGraphRAG demonstrates remarkable improvements over its predecessor:

Indexing Costs: LazyGraphRAG's indexing costs are just 0.1% of GraphRAG's, a staggering 1000-fold reduction[1][6].
Query Efficiency: For global queries, LazyGraphRAG achieves comparable answer quality to GraphRAG but at more than 700 times lower query cost[1][4].
Overall Performance: LazyGraphRAG significantly outperforms all competing methods on both local and global queries at just 4% of GraphRAG's global search cost[1][4].

Use Cases and Adaptability

While GraphRAG excels in scenarios requiring comprehensive analysis of large datasets, LazyGraphRAG's efficiency makes it ideal for:

One-off queries
Exploratory analysis
Streaming data applications
Cost-sensitive environments

LazyGraphRAG's ability to scale performance with increasing relevance test budgets also makes it an excellent benchmarking tool for RAG approaches[1][5].

Conclusion

LazyGraphRAG represents a significant leap forward in RAG technology. By addressing the cost and efficiency limitations of GraphRAG, it offers a more accessible and versatile solution for a wide range of applications. However, both technologies have their place, with GraphRAG still valuable for scenarios requiring extensive pre-processing and in-depth analysis of complex datasets.

As these technologies continue to evolve, they promise to reshape how we interact with and extract insights from large-scale information repositories, paving the way for more efficient and cost-effective AI-driven data analysis and decision-making processes.

Citations:
[1] LazyGraphRAG: Setting a new standard for quality and cost - Microsoft https://www.microsoft.com/en-us/research/blog/lazygraphrag-setting-a-new-standard-for-quality-and-cost/
[2] Microsoft GraphRAG vs. Neo4j + LangChain - Towards AI https://pub.towardsai.net/exploring-and-comparing-graph-based-rag-approaches-microsoft-graphrag-vs-neo4j-langchain-3837cd3dddef?gi=31803c600a7a
[3] Microsoft AI Introduces LazyGraphRAG: A New AI Approach to ... https://www.marktechpost.com/2024/11/26/microsoft-ai-introduces-lazygraphrag-a-new-ai-approach-to-graph-enabled-rag-that-needs-no-prior-summarization-of-source-data/
[4] Microsoft unveils hard-working, lower-cost LazyGraphRAG - The Stack https://www.thestack.technology/microsoft-lazygraphrag/
[5] Microsoft AI Introduces LazyGraphRAG: A Game-Changer in Cost ... https://blog.aitoolhouse.com/microsoft-ai-introduces-lazygraphrag-a-game-changer-in-cost-effective-graph-enabled-retrieval-without-prior-data-summarization/
[6] The cost is reduced by 1000 times! Microsoft will open source super ... https://www.lianpr.com/en/news/detail/3224

Dev.to post to Docusaurus blog (automation nodejs)

Pull Review with Scott Beeker — Fri, 08 Nov 2024 01:35:22 +0000

Hello Dev Community!
Today I'll provide you with a programmatic example of how to convert dev.to articles to a Docusaurus blog. This example will use Node.js to fetch articles from the dev.to API and create Markdown files compatible with Docusaurus blog posts.

First, let's set up the project and install the necessary dependencies:

mkdir devto-to-docusaurus
cd devto-to-docusaurus
npm init -y
npm install axios fs-extra front-matter

Now, create a file named convert.js and add the following code:

const axios = require('axios');
const fs = require('fs-extra');
const frontMatter = require('front-matter');
const path = require('path');

const DEV_TO_API_KEY = 'YOUR_DEV_TO_API_KEY';
const DEV_TO_USERNAME = 'YOUR_DEV_TO_USERNAME';
const OUTPUT_DIR = './blog';

async function fetchDevToArticles() {
  const response = await axios.get(`https://dev.to/api/articles/me/published`, {
    headers: { 'api-key': DEV_TO_API_KEY }
  });
  return response.data;
}

function convertToDocusaurusFrontMatter(article) {
  const date = new Date(article.published_at);
  return {
    title: article.title,
    authors: [DEV_TO_USERNAME],
    tags: article.tag_list,
    date: date.toISOString().split('T')[0],
    slug: article.slug,
    description: article.description,
  };
}

async function convertArticleToMarkdown(article) {
  const frontMatterContent = convertToDocusaurusFrontMatter(article);
  const markdown = `---
${Object.entries(frontMatterContent).map(([key, value]) => `${key}: ${Array.isArray(value) ? `[${value.join(', ')}]` : value}`).join('\n')}
---

${article.body_markdown}`;

  const fileName = `${frontMatterContent.date}-${article.slug}.md`;
  const filePath = path.join(OUTPUT_DIR, fileName);
  await fs.outputFile(filePath, markdown);
  console.log(`Created: ${filePath}`);
}

async function main() {
  try {
    const articles = await fetchDevToArticles();
    await fs.ensureDir(OUTPUT_DIR);

    for (const article of articles) {
      await convertArticleToMarkdown(article);
    }

    console.log('Conversion completed successfully!');
  } catch (error) {
    console.error('Error:', error.message);
  }
}

main();

Here's how this script works:

It fetches your published articles from dev.to using the API.
For each article, it converts the metadata to Docusaurus-compatible front matter.
It combines the front matter with the article's Markdown content.
It saves each article as a separate Markdown file in the blog directory.

To use this script:

Replace YOUR_DEV_TO_API_KEY with your actual dev.to API key[1].
Replace YOUR_DEV_TO_USERNAME with your dev.to username.
Run the script using node convert.js.

After running the script, you'll find your dev.to articles converted to Docusaurus-compatible blog posts in the blog directory[1][3].

To integrate these posts into your Docusaurus site:

Copy the generated Markdown files from the blog directory to your Docusaurus project's blog directory.
Ensure your docusaurus.config.js file has the blog plugin configured correctly[1][3].

Here's an example of how your docusaurus.config.js might look:

module.exports = {
  // ... other config options
  presets: [
    [
      '@docusaurus/preset-classic',
      {
        blog: {
          path: 'blog',
          routeBasePath: 'blog',
          blogTitle: 'My Dev.to Blog',
          blogDescription: 'A collection of my dev.to articles',
          blogSidebarCount: 'ALL',
          blogSidebarTitle: 'All Blog Posts',
          showReadingTime: true,
          editUrl: 'https://github.com/yourusername/your-repo/edit/main/website/',
        },
      },
    ],
  ],
  // ... other config options
};

This configuration sets up the blog plugin to use the blog directory and display all posts in the sidebar[1][3].

Remember to customize the editUrl and other options according to your project structure and preferences. With this setup, your dev.to articles will be seamlessly integrated into your Docusaurus blog.

Citations:
[1] https://docusaurus.io/docs/blog
[2] https://dev.to/dreamlogic/how-to-use-the-multi-blog-plugin-for-docusaurus-32a2
[3] https://docusaurus.io/docs/api/plugins/@docusaurus/plugin-content-blog
[4] https://dev.to/tuenguyen2911_67/inspired-by-docusaurus-2cm6
[5] https://dev.to/dianaiminza/documentation-using-docusaurus-40g5
[6] https://dev.to/seanyasno/starting-a-new-blogging-journey-with-docusaurus-3aap
[7] https://dev.to/lo_victoria2666/build-beautiful-documentation-websites-with-docusaurus-8o2
[8] https://dev.to/katiel/exploring-the-code-behind-docusaurus-pbk

Today in AI: Mixture of In-Context Learners

Pull Review with Scott Beeker — Wed, 06 Nov 2024 22:09:47 +0000

Mixture of In-Context Learners

Uses subsets of demonstrations to train experts via in-context learning. Given a training set, a trainable weighting function is used to combine the experts' next-token predictions.

This approach applies to black-box LLMs since access to the… pic.twitter.com/nhQRwYrVjz
— elvis (@omarsar0) November 6, 2024

Pretty cool!! Lets #connect

Creating a Remote Git Hub for Your Company(Without Github)

Pull Review with Scott Beeker — Wed, 06 Nov 2024 21:50:33 +0000

Creating a Remote Git Hub for Your Company: A Comprehensive Guide

In this article, we'll explore how to create a remote Git hub for your company without relying on GitHub. We'll use TypeScript and Go for the backend implementation, integrate MySQL for data storage, and implement user authentication using FIDO2. This solution provides a secure and customizable alternative to third-party hosting platforms.

Backend Implementation

TypeScript Server

Let's start by setting up the TypeScript server to handle Git operations:

import express from 'express';
import { execSync } from 'child_process';

const app = express();
const port = 3000;

app.post('/create-repo', (req, res) => {
  const { repoName } = req.body;
  try {
    execSync(`git init --bare /path/to/repos/${repoName}.git`);
    res.status(200).json({ message: 'Repository created successfully' });
  } catch (error) {
    res.status(500).json({ error: 'Failed to create repository' });
  }
});

app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

This TypeScript server provides an endpoint for creating new Git repositories on the server.

Go Git Server

Next, let's implement a Go server to handle Git push and pull operations:

package main

import (
    "fmt"
    "net/http"
    "os/exec"
)

func handleGitOperation(w http.ResponseWriter, r *http.Request) {
    repoPath := r.URL.Path[1:]
    gitCommand := r.Header.Get("X-Git-Command")

    cmd := exec.Command("git", gitCommand, "--stateless-rpc", repoPath)
    cmd.Stdin = r.Body
    cmd.Stdout = w
    cmd.Stderr = w

    if err := cmd.Run(); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
}

func main() {
    http.HandleFunc("/", handleGitOperation)
    fmt.Println("Git server running on :8080")
    http.ListenAndServe(":8080", nil)
}

This Go server handles Git push and pull operations by executing the appropriate Git commands.

Database Integration

To store repository metadata and user information, we'll use MySQL. Here's an example of how to set up the database connection and create tables:

import mysql from 'mysql2/promise';

const pool = mysql.createPool({
  host: 'localhost',
  user: 'your_username',
  password: 'your_password',
  database: 'git_hub',
});

async function createTables() {
  const connection = await pool.getConnection();
  try {
    await connection.query(`
      CREATE TABLE IF NOT EXISTS repositories (
        id INT AUTO_INCREMENT PRIMARY KEY,
        name VARCHAR(255) NOT NULL,
        owner_id INT NOT NULL,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
      )
    `);
    await connection.query(`
      CREATE TABLE IF NOT EXISTS users (
        id INT AUTO_INCREMENT PRIMARY KEY,
        username VARCHAR(255) NOT NULL,
        email VARCHAR(255) NOT NULL,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
      )
    `);
  } finally {
    connection.release();
  }
}

createTables();

This code sets up the MySQL connection and creates tables for storing repository and user information.

User Authentication with FIDO2

Implementing FIDO2 authentication provides a secure, passwordless login experience. Here's a basic example of how to integrate FIDO2 authentication:

import { Fido2Lib } from 'fido2-lib';

const f2l = new Fido2Lib({
  timeout: 60000,
  rpId: 'your-company.com',
  rpName: 'Your Company Git Hub',
  challengeSize: 128,
  attestation: 'none',
  cryptoParams: [-7, -257],
});

app.post('/register', async (req, res) => {
  const { username, email } = req.body;
  const challengeResponse = await f2l.attestationOptions();
  // Store challenge and user info in the database
  res.json(challengeResponse);
});

app.post('/login', async (req, res) => {
  const { credential } = req.body;
  try {
    const result = await f2l.assertionResult(credential, {
      challenge: 'stored_challenge',
      origin: 'https://your-company.com',
      factor: 'either',
    });
    // Verify the result and create a session
    res.json({ success: true });
  } catch (error) {
    res.status(401).json({ error: 'Authentication failed' });
  }
});

This code provides basic endpoints for FIDO2 registration and login. You'll need to implement additional logic to store and retrieve challenges and user credentials from the database.

Conclusion

By combining TypeScript and Go for the backend, MySQL for data storage, and FIDO2 for user authentication, you can create a robust and secure remote Git hub for your company. This solution offers full control over your source code and user management, without relying on third-party platforms like GitHub.

Remember to implement proper error handling, logging, and security measures in a production environment. Additionally, consider adding features like access control, code review processes, and integration with your existing development tools to create a comprehensive Git management solution tailored to your company's needs.

Forem: Pull Review with Scott Beeker

From Legacy Rest to GPC - Vanguard-Go ⚔️

So what is Vanguard?

Why Vanguard?

Prerequisites

Step-by-Step Guide

1. Define Your Protobuf Schema

2. Generate Code

3. Implement the Service

4. Set Up Vanguard Transcoder

5. Test the API

6. Optional: Add Compression and Configuration

Key Features of Vanguard

Example Use Case

Troubleshooting

Additional Resources

Promise.all()

Understanding Promise.all() in JavaScript

Syntax

Return Value

Fulfillment and Rejection

Practical Examples

Example 1: Basic Usage

Example 2: Handling Mixed Values

Example 3: Rejection Handling

Use Cases for Promise.all()

Conclusion

Server Side Web Assembly - Exploring the Unknown

Key Advantages of Server-Side WebAssembly

Use Cases

Challenges and Future Development

scalability...

Fediverse - The new sound of social networking

[Boost]

Mastering Rust's Lifetime System: A Guide to Memory Safety and Performance

Aarav Joshi ・ Dec 16

Star for Star Github Repo Thread....

mondayvibes #networking #connect

[Boost]

GraphRAG vs LazyGraphRAG: Revolutionizing Retrieval-Augmented Generation

GraphRAG: The Pioneer

LazyGraphRAG: The Game-Changer

Performance Comparison

Use Cases and Adaptability

Conclusion

Dev.to post to Docusaurus blog (automation nodejs)

Today in AI: Mixture of In-Context Learners

Creating a Remote Git Hub for Your Company(Without Github)

Backend Implementation

TypeScript Server

Go Git Server

Database Integration

User Authentication with FIDO2

Conclusion

Understanding `Promise.all()` in JavaScript

Use Cases for `Promise.all()`