The DMOJ judge-server is the core judging component of the DMOJ (Modern Online Judge) platform, responsible for executing and evaluating programming contest submissions in sandboxed environments. It features a plugin-based architecture supporting over 50 programming languages through language-specific executors, graders, and checkers. The system handles secure sandboxing via ptrace and seccomp (Linux) or ptrace (FreeBSD), manages problem configurations with automatic reloading, and communicates with the judge server using a custom packet protocol. Key entry points include the main judge daemon (dmoj), a CLI tool for local testing (dmoj-cli), and an autoconfiguration utility for runtime detection. The codebase demonstrates strong separation of concerns, with isolated components for sandboxing, subprocess communication, and output normalization that exhibit reusable patterns.
The AKS Store Demo is a polyglot microservices application designed to demonstrate deployment patterns on Azure Kubernetes Service (AKS). It simulates an online pet store where users can browse products, place orders, and administrators can manage inventory and view orders. The system comprises multiple independently deployable services: a Vue.js storefront and admin panel, a Node.js order service, a Go makeline service for order processing, a Rust product service for catalog management, a Python AI service for optional generative AI features, and Rust-based virtual customer and worker services for traffic simulation. Services communicate via REST APIs and a message queue (RabbitMQ or Azure Service Bus), with data persisted in DocumentDB (Azure Cosmos DB with MongoDB API). The application showcases strong engineering practices through its use of infrastructure-as-code (Terraform and Bicep), Kubernetes manifests managed via Kustomize for environment-specific configuration, and Azure Developer CLI (azd) hooks for automated provisioning and deployment. Each service includes health checks, Docker multi-stage builds, and observability hooks. The polyglot nature allows each service to use the most suitable language for its function, while the clear separation of concerns and well-defined interfaces enable independent development and scaling. The repository includes comprehensive unit, end-to-end, and traffic simulation tests to ensure reliability.
This repository is a benchmark suite for comparing the performance of different programming languages in solving the 'related posts' problem: given a list of posts with tags, compute the top 5 related posts for each post based on shared tags. The architecture consists of language-specific implementations (over 50 languages) that all follow the same algorithm: build a tag-to-post-index map, then for each post count shared tags via that map, and select the top 5 posts using a custom priority queue. The repository includes Dockerfiles for each language, helper scripts for running benchmarks, and a workflow that automates execution across multiple post counts (5k, 20k, 60k) and updates a README with results. The code demonstrates strong engineering practices: consistent algorithm across implementations, use of language-specific optimizations (e.g., SIMD, custom hash maps, parallelization), and careful attention to performance measurement (excluding I/O).
Polyglot is a Ruby gem that serves as a Jekyll plugin for internationalization (i18n) of static sites. It enables building a site in multiple languages by forking the Jekyll build process per language, patching core Jekyll classes (`Site`, `StaticFile`) to handle language-specific files, and providing Liquid tags for SEO headers (`I18n_Headers`) and URL relativization control (`static_href`). The plugin coordinates documents across languages, supports fallback to the default language, localizes `site.data` via language-specific subdirectories, and generates Netlify-compatible redirects. It is not a standalone application but a library that integrates deeply with Jekyll via hooks and monkey-patching. The repository includes a comprehensive demo site with 18 languages, a full RSpec test suite, CI via CircleCI, and extensive documentation in both README and `ai_docs/`. The codebase is well-structured, with clear separation of concerns (hooks, patches, liquid tags), and demonstrates non-trivial engineering in areas like parallel forking, regex-based URL relativization, and document coordination.
This repository is a polyglot web converter application built with Next.js. It provides a large collection of code transformations (e.g., JSON to TypeScript, SVG to JSX, GraphQL to Resolvers, HTML to Pug, etc.) in a user-friendly two-pane editor interface. The architecture is a monolith with each transformation implemented as a separate page under `pages/`, all sharing a common `ConversionPanel` component that manages the input/output editors, web workers for heavy processing, and server-side API routes for a few transforms that require Node.js native modules. External dependencies include numerous npm libraries for the actual conversion logic (e.g., `json_typegen_wasm`, `@svgr/core`, `graphql-codegen`), the Monaco editor for code editing, and the evergreen-ui component library for the UI. The application uses web workers extensively (via a custom `workerWrapper` utility) to offload CPU-intensive conversions off the main thread, ensuring a responsive UI. Data flows from the user's input editor, through a transformer function (which may call a web worker or an API endpoint), and into the output editor, with results automatically formatted by Prettier. The codebase is well-structured with a consistent pattern for each converter, making it straightforward to add new transformations.
Polynote is a polyglot notebook server that enables interactive data analysis in Scala, Python, SQL, and Vega. It provides a web-based IDE with Monaco editor, real-time kernel execution, rich visualizations (Vega-Lite, Matplotlib), and tight Apache Spark integration. The architecture is a monolith: a Scala server using ZIO effects, a custom binary WebSocket protocol, and a TypeScript frontend with its own reactive state management. Key entry points are the server main class (Main.scala) and the headless notebook runner (NotebookRunner.scala). Data flows from cell edits through WebSocket messages to the kernel, which executes code and streams results back. External dependencies include JVM, Python via Jep, Spark, Coursier for dependency resolution, and various frontend libraries. While primarily an application, it also serves as a data exploration platform with streaming data abstractions and visualization capabilities.
Stan's Robot Shop is a polyglot microservice application designed as a sandbox for learning container orchestration and monitoring. The system comprises eight services (user, catalogue, cart, payment, shipping, ratings, dispatch, web) each built with a different technology stack (Node.js, Java, Python, Go, PHP) and communicating via HTTP or RabbitMQ. Data is persisted in MongoDB (catalogue, user), Redis (cart, session), and MySQL (shipping, ratings). The application provides Docker Compose and Kubernetes manifests for deployment, along with Instana integration for automatic tracing and metrics collection. While the application successfully demonstrates microservice patterns and technology diversity, the codebase exhibits significant technical drift due to outdated dependencies (e.g., Express 4.15, Redis 2.8, Spring Boot 2.3) and lacks modern practices such as comprehensive error handling and security measures. The architecture is modular and service boundaries are clear, but the implementation relies on boilerplate for tracing and health checks. A notable reusable component is the Haversine distance calculator in the shipping service, which is isolated and dependency-free.