Notes
  • Blockchain
  • About this repository
  • References
  • Carret Position
  • Loggia and Balcony
  • automobile
    • Motorbike
  • computer
    • Kubernetes Event-driven Autoscaling (KEDA)
    • Protobuf
    • [[Amazon]] [[Identity and Access Management]] ([[IAM]])
    • Apdex
    • Architecture Decision Record
    • Audio
    • [[Amazon Web Services]] (AWS) Lambda
    • Blockchain
    • C/C++
    • Cache line
    • Caching strategies
    • Database
    • Design Patterns
    • Docker compose
    • Event Driven Design
    • False sharing
    • Git
    • [[Go]] common mistakes
    • [Go] [[subtests]]
    • Go
    • Janus
    • Jest
    • Kubernetes
    • Log-Structured Merge-tree
    • Media server
    • MySQL: Charset, Collation and UCA
    • Netflix
    • Opus Codec
    • Process, Thread
    • ReDoS - [[Regular expression]] Denial of Service
    • Rust
    • ScyllaDB
    • Shell Functions
    • Signals (The GNU Library)
    • Solidity
    • Sources
    • SQL
    • Transmission Control Protocol (TCP)
    • Ten design principles for Azure applications
    • Transient Fault Handling
    • twemproxy
    • Video
    • Web2 vs Web3
    • WebRTC
    • Microservice architecture
      • 3rd party registration
      • Command Query Responsibility Segregation (CQRS)
      • Access token
      • Aggregate
      • API Composition
      • API gateway/Backends for Frontends
      • Application metrics
      • Audit logging
      • Circuit Breaker
      • Client-side discovery
      • Client-side UI composition
      • Consumer-driven contract test
      • Consumer-side contract test
      • Database per Service
      • Decompose by business capability
      • Decompose by subdomain
      • Distributed tracing
      • Domain event
      • Domain-specific
      • Event sourcing
      • Exception tracking
      • Externalized configuration
      • Health check API
      • Log aggregation
      • Log deployments and changes
      • Messaging
      • Microservice architecture
      • Microservice Chassis
      • Multiple Service instances per host
      • Polling publisher
      • Remote Procedure invocation
      • Saga
      • Self-contained service
      • Self registration
      • Server-side discovery
      • Server-side page fragment composition
      • Serverless deployment
      • Service Component test
      • Service deployment platform
      • Service instance per Container
      • Service instance per VM
      • Service mesh
      • Service per team
      • Service registry
      • Service template
      • Shared database
      • Single Service instance per host
      • Transaction log tailling
      • Transactional outbox
  • food-and-beverage
    • Cheese
    • Flour
    • Japanese Plum liqueur or Umeshu
    • Sugar
  • management
    • Software Engineering processes
  • medic
    • Desease, disorder, condition, syndrome
    • Motion Sickess
  • others
    • Elliðaey
    • ASCII art
    • Empirical rule
    • Hindsight bias
    • Outcome bias
    • Tam giác Reuleaux
    • Luật Việt Nam
  • soft-skills
    • Emotional intelligence
Powered by GitBook
On this page
  • Rust and other languages
  • [[Go]]
  1. computer

Rust

PreviousReDoS - [[Regular expression]] Denial of ServiceNextScyllaDB

Last updated 2 years ago

Rust and other languages

[[Go]]

  • On-par performance

    Both Go and Rust have excellent built-in, high-performance standard build and dependency management tools. Rust will almost always beat Go in run-time benchmarks due to its fine-grained control over how threads behave and how resources are shared between threads. Both Rust and Go use a standard formatting tool—gofmt for Go and rustfmt for Rust—which rewrites your code automatically using the canonical style.

    Ultimately, Rust lets programmers get "closer to the metal" with more control (that is, the machine the code will be running on). By contrast, Go abstracts away from the architectural details to let programmers get closer to the problem they're trying to solve.

  • Ensuring security

    Rust's heavy emphasis on preventing memory-related [[security]] vulnerabilities means programmers have to go out of their way to perform tasks that would be simpler in other languages, including Go. However, Go isn't [[insecure]]. Rust just happens to be king for memory safety. One of the biggest causes of bugs and security vulnerabilities is accessing memory unsafely or incorrectly. Rust offers several concurrency paradigms to help avoid common memory safety pitfalls.

  • Ease of use

    Unlike interpreted languages, which tend to force developers into a particular way of approaching things, both Go and Rust are practical languages aimed at solving problems in whatever way is most appropriate for an application. It's no easy feat to guarantee memory-safe concurrency without compromising the developer experience.

    Rust and Go can both claim memory-safe concurrency and a good developer experience. Admittedly, coding with Rust is more difficult and takes longer. Overall, Rust has a steeper learning curve than Go. Additionally, the developer experience edge goes to Go when it comes to [[concurrency]].

Rust vs Go