Concurrency on Producthunt daily

comprehensive-rust

Wed, 03 Sep 2025 15:27:52 +0800

google/comprehensive-rust

Comprehensive Rust 🦀

This repository has the source code for Comprehensive Rust 🦀, a multi-day Rust course developed by the Android team. The course covers all aspects of Rust, from basic syntax to generics and error handling. It also includes deep dives on Android, Chromium, bare-metal, and concurrency.

Read the course at https://google.github.io/comprehensive-rust/.

Course Format and Target Audience

The course is used internally at Google when teaching Rust to experienced software engineers. They typically have a background in C++ or Java.

The course is taught in a classroom setting and we hope it will be useful for others who want to teach Rust to their team. The course will be less useful for self-study since you miss out on the discussions happening in the classroom. You don’t see the questions and answers and you don’t see the compiler errors we trigger when going through the code samples. We hope to improve on this via speaker notes and by publishing videos.

Press

Articles and blog posts from around the web which cover Comprehensive Rust:

2023-09-08: Teaching Rust in 5 days. Comprehensive Rust was used as a base for a 5-day university class on Rust.
2023-09-21: Scaling Rust Adoption Through Training. We published a blog post with details on the development of the course.
2023-10-02: In Search of Rust Developers, Companies Turn to In-House Training. About how Microsoft, Google, and others are training people in Rust.
2024-10-18: Rust Training at Scale | Rust Global @ RustConf 2024. What Google learnt from teaching Comprehensive Rust for more than two years.

Setup

The course is built using a few tools:

First install Rust by following the instructions on https://rustup.rs/. Then clone this repository:

1
2

git clone https://github.com/google/comprehensive-rust/
cd comprehensive-rust

Then install these tools with:

`1`	`cargo xtask install-tools`

Note We use xtask for task automation within the project (e.g. installing required tools). Xtask is not a package that you should install. Visit https://github.com/matklad/cargo-xtask for more information.

Commands

Here are some of the commonly used commands you can run in the project. Run cargo xtask to view all available commands.

Command	Description
`cargo xtask install-tools`	Install all the tools the project depends on.
`cargo xtask serve`	Start a web server with the course. You’ll find the content on http://localhost:3000. To serve any of the translated versions of the course, add the language flag (–language or -l) followed by xx, where xx is the ISO 639 language code (e.g. cargo xtask serve -l da for the Danish translation).
`cargo xtask rust-tests`	Test the included Rust snippets.
`cargo xtask web-tests`	Run the web driver tests in the tests directory.
`cargo xtask build`	Create a static version of the course in the `book/` directory. Note that you have to separately build and zip exercises and add them to book/html. To build any of the translated versions of the course, add the language flag (–language or -l) followed by xx, where xx is the ISO 639 language code (e.g. cargo xtask build -l da for the Danish translation). TRANSLATIONS.md contains further instructions.

Note On Windows, you need to enable symlinks (git config --global core.symlinks true) and Developer Mode.

Contributing

We would like to receive your contributions. Please see CONTRIBUTING.md for details.

Contact

For questions or comments, please contact Martin Geisler or start a discussion on GitHub. We would love to hear from you.

effect

Wed, 25 Jun 2025 15:30:56 +0800

Effect-TS/effect

Effect Monorepo

An ecosystem of tools to build robust applications in TypeScript

Introduction

Welcome to Effect, a powerful TypeScript framework that provides a fully-fledged functional effect system with a rich standard library.

Effect consists of several packages that work together to help build robust TypeScript applications. The core package, effect, serves as the foundation of the framework, offering primitives for managing side effects, ensuring type safety, and supporting concurrency.

Monorepo Structure

The Effect monorepo is organized into multiple packages, each extending the core functionality. Below is an overview of the packages included:

Package	Description
`effect`	Core package	README
`@effect/ai`	AI utilities	README
`@effect/ai-openai`	OpenAI utilities	README
`@effect/ai-anthropic`	Anthropic utilities	README
`@effect/cli`	CLI utilities	README
`@effect/cluster`	Distributed computing tools	README
`@effect/cluster-browser`	Cluster utilities for the browser	README
`@effect/cluster-node`	Cluster utilities for Node.js	README
`@effect/cluster-workflow`	Workflow management for clusters	README
`@effect/experimental`	Experimental features and APIs	README
`@effect/opentelemetry`	OpenTelemetry integration	README
`@effect/platform`	Cross-platform runtime utilities	README
`@effect/platform-browser`	Platform utilities for the browser	README
`@effect/platform-bun`	Platform utilities for Bun	README
`@effect/platform-node`	Platform utilities for Node.js	README
`@effect/platform-node-shared`	Shared utilities for Node.js	README
`@effect/printer`	General-purpose printing utilities	README
`@effect/printer-ansi`	ANSI-compatible printing utilities	README
`@effect/rpc`	Remote procedure call (RPC) utilities	README
`@effect/rpc-http`	HTTP-based RPC utilities	README
`@effect/sql`	SQL database utilities	README
`@effect/sql-clickhouse`	An `@effect/sql` implementation for ClickHouse.	README
`@effect/sql-d1`	An `@effect/sql` implementation for Cloudflare D1.	README
`@effect/sql-drizzle`	An `@effect/sql` implementation for Drizzle.	README
`@effect/sql-kysely`	An `@effect/sql` implementation for Kysely.	README
`@effect/sql-libsql`	An `@effect/sql` implementation using the `@libsql/client` library.	README
`@effect/sql-mssql`	An `@effect/sql` implementation using the mssql `tedious` library.	README
`@effect/sql-mysql2`	An `@effect/sql` implementation using the `mysql2` library.	README
`@effect/sql-pg`	An `@effect/sql` implementation using the `postgres.js` library.	README
`@effect/sql-sqlite-bun`	An `@effect/sql` implementation using the `bun:sqlite` library.	README
`@effect/sql-sqlite-do`	An `@effect/sql` implementation for Cloudflare Durable Objects sqlite storage.	README
`@effect/sql-sqlite-node`	An `@effect/sql` implementation using the `better-sqlite3` library.	README
`@effect/sql-sqlite-react-native`	An `@effect/sql` implementation using the `react-native-quick-sqlite` library.	README
`@effect/sql-sqlite-wasm`	An `@effect/sql` implementation using the `@sqlite.org/sqlite-wasm` library.	README
`@effect/typeclass`	Functional programming type classes	README
`@effect/vitest`	Testing utilities for Vitest	README

Documentation

Website

For detailed information and usage examples, visit the Effect website.

API Reference

For a complete API reference of the core package effect, see the Effect API documentation.

Introduction to Effect

Get started with Effect by watching our introductory video on YouTube. This video provides an overview of Effect and its key features:

Connect with Our Community

Join the Effect community on Discord to connect with other developers, ask questions, and share insights: Join Effect’s Discord Community.

Contributing via Pull Requests

We welcome contributions via pull requests! Here are some guidelines to help you get started:

Setting Up Your Environment

Begin by forking the repository and clone it to your local machine.

Navigate into the cloned repository and create a new branch for your changes:

`1`	`git checkout -b my-branch`

Ensure all required dependencies are installed by running:

`1`	`pnpm install # Requires pnpm version 10.4.0`

Making Changes

Implement Your Changes

Make the changes you propose to the codebase. If your changes impact functionality, please add corresponding tests to validate your updates.

Validate Your Changes

Run the following commands to ensure your changes do not introduce any issues:

pnpm codegen (optional): Re-generate the package entrypoints in case you have changed the structure of a package or introduced a new module.
pnpm check: Confirm that the code compiles without errors.
pnpm test: Execute all unit tests to ensure your changes haven’t broken existing functionality.
pnpm circular: Check for any circular dependencies in imports.
pnpm lint: Ensure the code adheres to our coding standards.
- If you encounter style issues, use pnpm lint-fix to automatically correct some of these.
pnpm test-types: Run type-level tests. Tests are written using tstyche.
pnpm docgen: Ensure the documentation generates correctly and reflects any changes made.

Document Your Changes

JSDoc Comments

When adding a new feature, it’s important to document your code using JSDoc comments. This helps other developers understand the purpose and usage of your changes. Include at least the following in your JSDoc comments:

A Short Description: Summarize the purpose and functionality of the feature.
Example: Provide a usage example under the @example tag to demonstrate how to use the feature.
Since Version: Use the @since tag to indicate the version in which the feature was introduced. If you’re unsure about the version, please consult with a project maintainer.
Category (Optional): You can categorize the feature with the @category tag to help organize the documentation. If you’re unsure about what category to assign, ask a project maintainer.

Note: A HTML utility file, code2jsdoc-example.html, has been added to assist with creating JSDoc @example comments. This web-based interface includes two text areas:

An input textarea for pasting example code.
An output textarea that dynamically generates formatted JSDoc @example comments.

This utility helps ensure consistent formatting and streamlines the process of documenting examples. See the following example of its usage:

Example Input:

import { Effect } from "effect"

console.log(Effect.runSyncExit(Effect.succeed(1)))
/*
Output:
{
  _id: "Exit",
  _tag: "Success",
  value: 1
}
*/

Output:

*
* @example
* ```ts
* import { Effect } from "effect"
*
* console.log(Effect.runSyncExit(Effect.succeed(1)))
* // Output:
* // {
* //   _id: "Exit",
* //   _tag: "Success",
* //   value: 1
* // }
* ```
*

By using this utility, you can save time and maintain consistency in your JSDoc comments, especially for complex examples.

Changeset Documentation

Before committing your changes, document them with a changeset. This process helps in tracking modifications and effectively communicating them to the project team and users:

`1`	`pnpm changeset`

During the changeset creation process, you will be prompted to select the appropriate level for your changes:

patch: Opt for this if you are making small fixes or minor changes that do not affect the library’s overall functionality.
minor: Choose this for new features that enhance functionality but do not disrupt existing features.
major: Select this for any changes that result in backward-incompatible modifications to the library.

Finalizing Your Contribution

Commit Your Changes

Once you have documented your changes with a changeset, it’s time to commit them to the repository. Use a clear and descriptive commit message, which could be the same message you used in your changeset:

`1`	`git commit -am 'Add some feature'`

Linking to Issues

If your commit addresses an open issue, reference the issue number directly in your commit message. This helps to link your contribution clearly to specific tasks or bug reports. Additionally, if your commit resolves the issue, you can indicate this by adding a phrase like ", closes #<issue-number>". For example:

`1`	`git commit -am 'Add some feature, closes #123'`

This practice not only helps in tracking the progress of issues but also automatically closes the issue when the commit is merged, streamlining project management.

Push to Your Fork

Push the changes up to your GitHub fork:

`1`	`git push origin my-branch`

Create a Pull Request

Open a pull request against the appropriate branch on the original repository:

main branch: For minor patches or bug fixes.
next-minor branch: For new features that are non-breaking.
next-major branch: For changes that introduce breaking modifications.

Please be patient! We will do our best to review your pull request as soon as possible.