ByteByteGo·1yEP144: The 9 Algorithms That Dominate Our World
Explore the 9 algorithms that dominate our world, understand the role of an API gateway in system design, learn how gRPC works, and compare Docker with Kubernetes for managing containerized applications. Also, review various API architecture styles and get insights into CI/CD pipeline and different app architecture patterns.
freeCodeCamp·1yLearn API Fundamentals and Architecture – A Beginner-Friendly Guide
APIs (Application Programming Interfaces) are essential tools that enable communication between different software systems. This guide covers the fundamentals of APIs, including their types (Open, Partner, Internal, Composite) and various architectures (REST, SOAP, GraphQL, gRPC). APIs streamline development by facilitating data exchange and integrating external functionalities securely and efficiently. Understanding these concepts helps developers choose the right API architecture based on performance, scalability, ease of use, and security needs.
The Coding Gopher·1y99% of Developers Don't Get RPCs
RPC, or Remote Procedure Call, is a critical communication protocol in distributed systems, allowing for code execution on remote systems as if they were local. This method abstracts networking complexities, making it ideal for microservices and internal systems that require efficiency and strict contracts. Unlike REST, which uses HTTP verbs and is better for external APIs, RPC offers granular function-level control, better performance with binary formats like Protobuf, and advanced capabilities like streaming and retries. gRPC enhances these benefits with efficient communication and built-in logging and metrics, making it a superior choice for modern backend architectures.
LogRocket·52wgRPC vs REST: Choosing the best API design approach
The post compares gRPC and REST, two prominent API design approaches, highlighting their differences in protocol, performance, and use cases. REST uses HTTP/1.1 and text-based formats such as JSON, making it suitable for public APIs and browser applications. gRPC leverages HTTP/2 and Protocol Buffers for efficient communication, ideal for microservices and performance-sensitive environments. Key factors such as serialization, latency, and payload size are discussed, helping developers choose the right approach for their projects.
Awesome Java Newsletter·38wJava desktop app with Shadcn UI
Building modern desktop applications with Java doesn't have to mean using outdated UI toolkits like Swing or JavaFX. This guide demonstrates how to create a cross-platform Java desktop app using web technologies including shadcn/ui, React, and TypeScript. The approach uses JxBrowser to embed a Chromium-based web view, serves web resources from the classpath for security, and implements type-safe communication between JavaScript and Java using Protobuf and gRPC. This hybrid approach combines the power of Java backend with modern web UI capabilities.
Medium·45wWhy We Replaced Kafka with gRPC for Service Communication
A development team replaced Kafka with gRPC for synchronous service communication in their loan servicing platform after experiencing issues with debugging, latency, and operational complexity. While keeping Kafka for appropriate use cases like audit logs and fan-out patterns, they found gRPC provided better performance (70-80% latency reduction), easier debugging, and simpler infrastructure management for request-response interactions. The key lesson was using each tool for its intended purpose rather than forcing one solution everywhere.
YouTube·44wEverything I did to become an expert in Golang (you can do this too)
A senior ML engineer at Twitch shares his 4-year journey from Go beginner to expert, detailing practical steps including building HTTP services, CLI tools, gRPC microservices, and pipeline scripts. He emphasizes the importance of reading 'Effective Go' documentation, practicing with real projects, and recommends specific books and resources for mastering Go development, testing, and best practices.
Fermyon·36wAnnouncing Spin 3.4
Spin 3.4 introduces HTTP/2 support for outgoing requests, enabling seamless integration with gRPC-based backends and improving performance through multiplexed connections. The release adds PostgreSQL connection pooling for better database performance and expands supported data types including UUID, JSONB, and array types. Additionally, Spin templates now include schema directives in spin.toml files for automatic validation and code completion in editors.
Dev Tools·45wChiko - TUI gRPC client
Chiko is a Terminal User Interface client for gRPC that simplifies testing and interacting with gRPC services. Built with grpcurl and rivo's tview libraries, it provides an intuitive visual interface to overcome the complexity of remembering command-line flags and syntax when working with gRPC services.
Community Picks·1ygRPC vs REST vs GraphQL: Comparison & Performance
Comparing REST API, GraphQL, and gRPC, the post explores their deployment on a Kubernetes cluster, measuring latency, CPU, memory, and network usage. It highlights the strengths and weaknesses of each, showing gRPC excelled under high load with the lowest resource usage, while REST API performed reliably with lower latency under moderate load. GraphQL struggled at higher requests per second due to its query engine overhead.
Awesome Go·39wHow I Made Europe Searchable From a Single Server - The Story of HydrAIDE
A developer built HydrAIDE, a custom data engine that indexes millions of European websites from a single server using only 3% CPU load. Instead of traditional databases, the system uses thousands of small binary files for O(1) data access, leveraging modern SSD performance. The engine powers precise B2B partner searches across Europe and is now open-source with Go SDK support and Python/Node.js SDKs in development.
The Coding Gopher·18w99% of Developers Don't Get gRPC
gRPC is a high-performance framework for communication between distributed systems using protocol buffers for binary serialization and HTTP/2 for transport. It supports four communication patterns: unary RPC, server streaming, client streaming, and bidirectional streaming. Compared to REST APIs, gRPC offers better efficiency through smaller message sizes, faster serialization, multiplexing, and type safety with automatic code generation. It's particularly suited for microservices architectures and backend-to-backend communication in distributed systems.
Nordic APIs·21w4 API Architectural Styles You Should Know
REST, webhooks, gRPC, and HATEOAS each serve distinct API design needs. REST offers simple, stateless, cacheable interactions ideal for standard web services and CRUD operations. Webhooks enable real-time, event-driven communication without polling, perfect for automation and reactive applications. gRPC provides high-performance, low-latency communication using HTTP/2 and Protobuf, supporting multiple streaming patterns for microservices. HATEOAS enables dynamic discoverability through hypermedia links, offering flexibility and potential for AI agent integration. The choice depends on specific requirements like real-time events, performance needs, or dynamic navigation capabilities.
Awesome Go·1ygRPC API Gateway: Bridging the Gap Between REST and gRPC
gRPC API Gateway facilitates the exposure of REST API endpoints for gRPC servers by providing enhanced configuration flexibility, modern OpenAPI support, comprehensive documentation, robust error handling, and extended streaming support. It improves upon the original gRPC Gateway with features like HTTP/JSON to gRPC translation, extensive control over API behavior, optimized OpenAPI 3.1 specifications, and seamless integration with contemporary API tools.
Quarkus·29wGrpc Zero
Quarkus gRPC Zero eliminates the need for native protoc binaries by running gRPC code generation entirely within the JVM. It embeds libprotobuf compiled to WebAssembly and translated to Java bytecode using Chicory, enabling portable and consistent builds across all platforms. Developers can continue writing .proto files as usual while avoiding platform-specific toolchain maintenance, simplifying CI pipelines, and reducing dependencies. The extension is currently experimental and available as a drop-in replacement for the standard quarkus-grpc-codegen artifact.
Medium·27wProtocol Buffers Over HTTP: You Don’t Need gRPC to Use Protobuf
Protocol Buffers can be used directly over standard HTTP without gRPC. The article demonstrates building a Go HTTP server that serves Protobuf-encoded binary data, proving that Protobuf is just a serialization format independent of the transport layer. It includes a working example with two endpoints: one returning Protobuf binary data and another decoding it back to JSON, showing how to leverage Protobuf's benefits (smaller payload size, faster serialization, type safety) while maintaining existing HTTP infrastructure.
Spring·26wSpring gRPC Next Steps for 1.0.0
Spring gRPC 1.0 will support Spring Boot 4.0 as a standalone project rather than being merged into Spring Boot 4.0 as originally planned. The autoconfiguration merge is now targeted for Spring Boot 4.1. Users can upgrade from version 0.12.0 by simply changing the version number in their dependency management, with minimal code changes required. The autoconfiguration and starter dependencies will be deprecated immediately upon release to signal the planned migration to Spring Boot 4.1, though this deprecation is purely about dependency coordinate changes.
System Design Newsletter·27wHow Remote Procedure Call Works
Remote Procedure Call (RPC) enables services to communicate efficiently by making remote function calls feel like local ones. The protocol uses client stubs and server skeletons to handle marshaling, network transmission, and unmarshaling automatically. Key failure handling strategies include timeouts, retries with idempotency safeguards, circuit breakers, and deadline propagation. Real-world implementations require service discovery, backward-compatible API evolution, streaming support, and standardized error codes. While RPC offers high performance and simple programming models through frameworks like gRPC, it creates tight coupling and requires specialized tooling compared to REST APIs.
Spring·51wSpring gRPC Promoted!
Spring gRPC has been promoted from experimental to a full member of the Spring Portfolio, marking symbolic and support changes. The recent release 0.8.0 updates dependencies, enhanced gRPC client stub creation, and outlined future transitions alongside Spring Boot 4.0.0. It supports easier configuration and integration with Spring Boot applications.
Baeldung·44wA Guide to Spring gRPC Project
Spring gRPC project enables developers to build gRPC servers within Spring Boot applications with minimal configuration. The tutorial covers setting up a project using Spring Initializr, defining Protocol Buffer files for service contracts, generating Java classes from proto files using Maven plugins, and implementing concrete gRPC services with Spring's dependency injection. A practical calculator service example demonstrates the complete workflow from proto definition to testing with gRPCurl.
Awesome Go·1yScaling gRPC With Kubernetes (Using Go)
gRPC is a robust choice for real-time microservice communication due to features like server push and streams, built on HTTP/2. However, scaling gRPC with Kubernetes can be problematic because its persistent TCP connections can cause uneven load distribution and resource wastage. Implementing headless services and client-side load-balancing in a round-robin manner can help optimize server utilization. Additionally, using a DNS resolver ensures the client is aware of new server replicas in real-time.
Spring·1ySpring gRPC 0.4.0 for great good!
Spring gRPC 0.4.0 has been released, offering a smooth experience for gRPC integration with Spring. This release emphasizes easy setup using Spring Initializr, compatibility with GraalVM, and support for HTTP/2. The post provides a guide on setting up Spring gRPC with Java 23, recommending tools like SDKMAN for JDK management.