Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/kbrdn1/exercism

Comprehensive programming language learning repository with Exercism exercises, progress tracking, and detailed learning roadmaps for systematic skill development.
https://github.com/kbrdn1/exercism

exercism go languages learning multi-languages rust

Last synced: 2 months ago
JSON representation

Comprehensive programming language learning repository with Exercism exercises, progress tracking, and detailed learning roadmaps for systematic skill development.

Awesome Lists containing this project

README 

          
# 🚀 Multi-Language Programming Journey - Exercism



A comprehensive learning roadmap for mastering **Go** and **Rust** through structured practice with Exercism's excellent exercise collections.



## 🌟 About Exercism



**Exercism** is a free, open-source platform designed to help you get really good at programming. With **77 programming languages** and over **7,329 coding exercises**, Exercism offers a unique blend of learning, practice, and **human mentoring** - all completely **free, forever**.



### What Makes Exercism Special?

- **🎯 Learn by Doing** - Solve real coding problems that build understanding

- **👥 Human Mentoring** - Get personalized feedback from experienced developers

- **🔧 CLI-First** - Work locally in your preferred environment

- **🌐 Browser Support** - Try languages without local installation

- **🤖 Automated Analysis** - Instant feedback on your solutions

- **🏆 Community-Driven** - Independent, not-for-profit organization



## 📊 Overall Progress



| Language | Completed | In Progress | Available | Locked | Total | Progress |

|----------|-----------|-------------|-----------|--------|-------|----------|

| **Go** | 13 ✅ | 0 🔄 | 113 📋 | 17 🔒 | 141 | 9.2% |

| **Rust** | 1 ✅ | 0 🔄 | 97 📋 | 0 🔒 | 98 | 1.0% |

| **Total** | **14** | **0** | **210** | **17** | **239** | **5.9%** |



## 🎯 Current Focus



### 🟢 **Go Track** - *Primary Focus*

- **Status**: Strong foundation established

- **Current**: All current exercises completed!

- **Recent**: Completed Structs and Slices

- **Next**: Ready for Methods and Interfaces



### 🟡 **Rust Track** - *Getting Started*

- **Status**: Just beginning the journey

- **Current**: Ready to tackle first exercises

- **Recent**: Completed Hello World

- **Next**: Reverse String and basic syntax



## 🗂️ Project Structure



```

exercism/

├── README.md                 # This file - Global overview

├── go/                       # Go learning track

│   ├── README.md            # Go-specific roadmap

│   ├── hello-world/         # Completed exercises

│   ├── lasagna/

│   ├── ...

│   ├── need-for-speed/      # Completed

│   └── card-tricks/         # Completed

└── rust/                    # Rust learning track

    ├── README.md            # Rust-specific roadmap

    ├── hello-world/         # Completed

    └── reverse-string/      # Available to start

```



## 🎯 Learning Strategy



### **Phase 1: Go Foundation** (Current)

- **Goal**: Master Go fundamentals and syntax

- **Timeline**: 2-3 months

- **Target**: Complete 30+ Go exercises

- **Focus Areas**: 

  - Basic syntax and data types

  - Control structures and functions

  - Structs, methods, and interfaces

  - Error handling and concurrency basics



### **Phase 2: Rust Introduction** (Next)

- **Goal**: Start Rust fundamentals while maintaining Go momentum

- **Timeline**: 1-2 months parallel learning

- **Target**: Complete 15+ Rust exercises

- **Focus Areas**:

  - Ownership and borrowing concepts

  - Pattern matching and enums

  - Error handling with Result/Option

  - Basic memory management



### **Phase 3: Advanced Concepts** (Future)

- **Goal**: Tackle advanced topics in both languages

- **Timeline**: 3-4 months

- **Target**: Medium/Hard exercises in both tracks

- **Focus Areas**:

  - Advanced concurrency patterns

  - Performance optimization

  - Complex data structures

  - Language-specific advanced features



## 🛠️ Quick Start



### Prerequisites

```bash

# Install Go

go version  # Should be 1.19+



# Install Rust

rustc --version  # Should be 1.70+

cargo --version



# Install Exercism CLI

exercism version

```



### Running Exercises



#### Go

```bash

cd exercism/go/[exercise-name]

go test                    # Run tests

go test -v                 # Verbose output

exercism submit *.go       # Submit solution

```



#### Rust

```bash

cd exercism/rust/[exercise-name]

cargo test                 # Run tests

cargo test -- --nocapture # With output

exercism submit src/lib.rs # Submit solution

```



## 📚 Language-Specific Resources



### 🟢 **Go Resources**

- [Go Tour](https://go.dev/tour/) - Interactive tutorial

- [Effective Go](https://go.dev/doc/effective_go) - Best practices

- [Go by Example](https://gobyexample.com/) - Practical examples

- [Go Documentation](https://go.dev/doc/) - Official docs



### 🟡 **Rust Resources**

- [The Rust Book](https://doc.rust-lang.org/book/) - Official guide

- [Rust by Example](https://doc.rust-lang.org/rust-by-example/) - Practical examples

- [Rustlings](https://github.com/rust-lang/rustlings) - Interactive exercises

- [Rust Documentation](https://doc.rust-lang.org/) - Official docs



## 🔗 Quick Navigation



- **[Go Learning Track →](./go/README.md)** - Detailed Go roadmap and progress

- **[Rust Learning Track →](./rust/README.md)** - Detailed Rust roadmap and progress



## 🤔 Why Learn Both Languages?



### **Go Strengths**

- **Simplicity**: Easy to learn and read

- **Concurrency**: Excellent goroutines and channels

- **Performance**: Fast compilation and execution

- **Ecosystem**: Great for web services, APIs, DevOps tools



### **Rust Strengths**

- **Memory Safety**: Zero-cost abstractions without garbage collection

- **Performance**: System-level performance with safety

- **Concurrency**: Fearless concurrency with ownership system

- **Ecosystem**: Great for systems programming, web assembly, blockchain



### **Complementary Skills**

- **Go**: Rapid development, microservices, cloud-native applications

- **Rust**: System programming, performance-critical applications, embedded systems

- **Together**: Full-stack systems programming capabilities



## 📈 Progress Tracking



### **Learning Metrics**

- **Exercises Completed**: 14/239 (5.9%)

- **Concepts Mastered**: 19+ across both languages

- **Time Investment**: ~2-3 hours per week per language

- **Consistency**: Daily practice goal



### **Skill Development**

- **Problem Solving**: Algorithm implementation across languages

- **Language Comparison**: Understanding design philosophies

- **Best Practices**: Idiomatic code in each language

- **Testing**: TDD approach with language-specific test frameworks



## 🏆 Achievements



### **Go Achievements**

- ✅ **First Steps**: Completed Hello World and basic syntax

- ✅ **Control Flow Master**: Mastered conditionals and loops

- ✅ **String Manipulator**: Advanced string operations

- ✅ **Slice Master**: Mastered dynamic arrays and collections

- ✅ **Struct Master**: Mastered custom data types and methods

- ✅ **Loop Master**: Mastered for loops and iteration patterns

- ✅ **Function Master**: Mastered variadic functions and advanced function patterns

- 🎯 **Ready for Next Level**: All current exercises completed!



### **Rust Achievements**

- ✅ **Hello Rust**: Completed first Rust program

- 🎯 **Next**: Ready for string manipulation exercises



## 🤝 Community & Support



### **Learning Approach**

- **Mentor Reviews**: Request feedback on Exercism solutions

- **Community**: Engage with Exercism and language communities

- **Documentation**: Maintain detailed learning notes

- **Comparison**: Cross-language concept mapping



### **Contribution Goals**

- Share learning insights and alternative solutions

- Help other learners through mentoring

- Contribute to open-source projects in both languages

- Create learning resources and tutorials



---



## 📝 Learning Notes



> **"The best way to learn a programming language is by solving real problems. This dual-track approach with Go and Rust provides complementary perspectives on modern systems programming - Go's simplicity and Rust's safety, together forming a powerful toolkit for any developer."**



### **Key Insights**

- **Go**: Focus on simplicity and rapid development

- **Rust**: Emphasize safety and performance

- **Both**: Strong typing, modern tooling, active communities



**Last Updated**: December 2024  

**Next Review**: Weekly progress updates  

**Learning Pace**: Consistent daily practice with weekly milestone reviews