Summer 2025 Elective Course - A comprehensive 8-blocks intensive course teaching modern full-stack development with Go backend and Flutter frontend, emphasizing real-world software engineering practices.
- 🚀 Rapid Prototyping: Learn to quickly test hypotheses and build MVPs with modern tech stack
- 🧪 Automated Testing: Every lab includes comprehensive testing with CI/CD pipelines
- 📹 Complete Recordings: All lectures and labs recorded in dual format (screen + front camera)
- 👥 Peer Review System: Real-world code review workflow with peer feedback
- ⚡ Fast-Track Option: Pass the entire course by completing one comprehensive project
- Backend (Go) – REST APIs, PostgreSQL, gRPC, micro-services
- Frontend (Flutter) – cross-platform UI, Riverpod, gRPC/HTTP clients
- DevOps – Docker, GitHub Actions, CI/CD
- Software Engineering – Clean Architecture, TBD, code review, testing, documentation, teamwork
Format: Each lecture and lab is available in two formats:
- Screen Recording: Slides, code demonstrations with AI-generated subtitles
- Front Camera: Instructor view with classroom interaction and explanations
YouTube playlist of lectures and labs
VK Video playlist of lectures and labs
| Block | Topic | Go Focus | Flutter Focus | Integration |
|---|---|---|---|---|
| 1 | Foundations | syntax, structs | widgets, layout | — |
| 2 | Concurrency & Streams | goroutines, channels | async/await, StreamBuilder | real-time calls |
| 3 | Data & APIs | HTTP server, middleware | HTTP client, models | REST |
| 4 | Database & Persistence | PostgreSQL, GORM | SQLite/local-store | CRUD |
| 5 | Patterns & Testing | clean architecture, mocks | Riverpod, tests | E2E |
| 6 | Auth & Security | JWT, hashing | secure storage | auth flow |
| 7 | WebSockets & gRPC | WS server, gRPC | WS/gRPC clients | streaming |
| 8 | Docker & Production | containers, logging | build/PWA | CI/CD |
Each block consists of:
- 1 Lecture (1.5 hours): Deep theory, concepts, and comprehensive code examples
- 1 Lab (1.5 hours): Extended hands-on implementation with both Go and Flutter
Block 1: Foundations
- Go: Basic syntax, functions, structs, packages
- Flutter: Widgets, layouts, basic UI components, stateful/stateless widgets
- Integration: None
- Deep Dive: Memory management, Go idioms, Flutter widget lifecycle
Block 2: Concurrency & Streams
- Go: Goroutines, channels, select statements, worker pools, context package
- Flutter: Async/await, futures, streams, StreamBuilder
- Integration: Concurrent API calls and real-time data updates
- Deep Dive: Advanced concurrency patterns, stream transformations
Block 3: Data & APIs
- Go: HTTP servers, routing, middleware, JSON APIs, validation, error handling
- Flutter: HTTP client, data models, serialization, caching
- Integration: RESTful API communication and robust data handling
- Deep Dive: API design patterns, advanced serialization, performance
Block 4: Database & Persistence
- Go: PostgreSQL integration, GORM, migrations, transactions
- Flutter: Local storage, SQLite, data caching
- Integration: CRUD operations
- Deep Dive: Database optimization, complex queries, data architecture
Block 5: Advanced Patterns & Testing
- Go: Clean architecture, dependency injection, testing, mocking
- Flutter: State management (Riverpod+Bloc), testing, navigation
- Integration: End-to-end testing
- Deep Dive: Design patterns, advanced testing strategies, code quality
Block 6: Authentication & Security
- Go: JWT tokens, password hashing, middleware, validation, security best practices
- Flutter: Authentication flow, secure storage, session management
- Integration: Secure user authentication and authorization
- Deep Dive: Security vulnerabilities, encryption, secure coding practices
Block 7: WebSockets & gRPC
- Go: WebSocket servers, gRPC services, Protocol Buffers, streaming APIs
- Flutter: WebSocket clients, gRPC client integration, real-time updates
- Integration: Real-time communication and high-performance API calls
- Deep Dive: gRPC streaming, WebSocket scaling, performance optimization
Block 8: Docker & Production
- Go: Containerization, environment config, logging, performance
- Flutter: Build optimization, PWA, deployment strategies
- Integration: Full production deployment with CI/CD
- Deep Dive: Production best practices, scaling, observability
Students build comprehensive full-stack applications covering all 8 blocks. Detailed requirements and guidelines available in docs/final-project/final-project-guidelines.md.
Students can pass the full course by completing a comprehensive project covering all 8 blocks. Requirements are detailed in docs/fast-track/tech-requirements.md.
Fast-Track Projects:
- Backend: Go 1.24.3+, http, GORM, PostgreSQL, gRPC, Protocol Buffers
- Frontend: Flutter 3.32.1+, Riverpod(Bloc), HTTP client, gRPC client
- Infrastructure: Docker, Docker Compose, GitHub Actions
- Database: PostgreSQL 17.5+, database migrations
- Testing: Go testing, Flutter testing, integration tests
| Item | Points |
|---|---|
| Attendance | 14 (7*2) |
| Lab assignments | 42 (7*6) |
| Peer review | 14 (7*2) |
| Final team project | 30 |
Full pipeline documentation with screenshots available in docs/submission/CONTRIBUTING.md
- Setup: Fork repository, clone locally, add upstream remote
- Development: Create feature branch (
lab01-surname-name), implement lab requirements, test locally - Local PR: Create pull request in your fork with detailed description
- Global PR: Submit pull request to main repository with link to local PR
- Submission: Submit global PR link to Moodle for grading
- Branch naming:
labXX-surname-name(all lowercase, no spaces) - Commit messages: Start with
labXX:prefix, use present tense - Testing: Ensure all tests pass (
make test) and code is linted (make lint) - Documentation: Include comprehensive descriptions in pull requests
Detailed guidelines and assignments available in docs/peer-review/peer-review-guidelines.md
- Assignment: Check peer review table for your assigned students (2 per lab)
- Locate PRs: Find pull requests for assigned students in main repository
- Review Code: Examine files changed, test implementation, add comments
- Submit Links: Submit 2 review comment links to Moodle (1 point each)
sum25-go-flutter-course/
├── backend/ # Go backend source code
│ ├── cmd/ # Application entry points
│ ├── internal/ # Private application code
│ ├── tests/ # Integration tests
│ ├── go.mod # Go module definition
│ └── Dockerfile # Backend container
├── frontend/ # Flutter frontend source code
│ ├── lib/ # Dart source code
│ ├── test/ # Unit and widget tests
│ ├── web/ # Web configuration
│ ├── pubspec.yaml # Flutter dependencies
│ ├── nginx.conf # Web server configuration
│ └── Dockerfile # Frontend container
├── labs/ # Lab assignments and solutions
│ ├── lab01/ # Lab 1: Foundations
│ ├── lab02/ # Lab 2: Real-time Chat (Concurrency & Streams)
│ ├── lab03/ # Lab 3: REST API Chat System (Data & APIs)
│ ├── lab04/ # Lab 4: Database & Persistence
│ ├── lab05/ # Lab 5: Advanced Patterns (Auth & Security)
│ ├── lab06/ # Lab 6: gRPC Microservices & WebSocket Communication
│ └── lab07/ # Lab 7: CI/CD, Docker, and Deployment
├── slides/ # Course presentation materials
│ ├── lecture00/ # Course introduction
│ ├── lecture01/ # Lecture 1: Foundations
│ ├── lecture02/ # Lecture 2: Concurrency & Streams
│ ├── lecture03/ # Lecture 3: Data & APIs
│ ├── lecture04/ # Lecture 4: Database & Persistence
│ ├── lecture05/ # Lecture 5: Advanced Patterns
│ ├── lecture06/ # Lecture 6: Communication & Microservices
│ └── lecture07/ # Lecture 7: CI/CD & Deployment
├── docs/ # Documentation
│ ├── fast-track/ # Fast-track project requirements
│ ├── final-project/ # Final project guidelines
│ ├── peer-review/ # Peer review assignments & guidelines
│ └── submission/ # Submission workflow documentation
├── feedback/ # Course feedback and analytics
│ ├── data/ # Survey data
│ ├── figures/ # Generated charts
│ ├── images/ # Course images
│ └── scripts/ # Feedback analysis scripts
├── .github/ # GitHub configuration
│ └── workflows/ # CI/CD pipelines
├── scripts/ # Development scripts
├── docker-compose.yml # Local development environment
├── Makefile # Common development tasks
└── README.md # This file
- Pacing & Time Management: The most frequent feedback was the need for better time distribution and more realistic deadlines.
- Course Organization: Start earlier and maintain a consistent schedule throughout the semester.
- Material Depth: Strive for a balance between comprehensive coverage and a digestible learning pace.
- GitHub Workflow: This was a highlight for many—will definitely keep and further enhance this aspect!
- Time Management & Scheduling: Adopt a more realistic schedule, extending the course from 1 month to 2 months, with only 1 lecture per week.
- Structured Progression: Implement a clearer progression from basics to advanced topics, potentially dividing into two tracks: beginners and progressing students.
- Unified Lab Theme: All lab tasks will follow a single theme, with each topic building step-by-step on the previous one.
- Stable CI/CD & Requirements: All CI/CD pipelines will be tested in advance, and deadlines/requirements will remain unchanged after publication.
The course feedback is visualized in comprehensive graphs, representing students' responses collected after course completion. These visualizations provide insights into various aspects of the course, including overall impressions, skill development, peer interactions, and instructor effectiveness.
All survey charts are generated by feedback/scripts/final_feedback.py and stored in feedback/figures/.
General sentiment and overall impressions of students towards the course upon completion.
Reflections on new skills and knowledge gained from the course, showing personal growth and development.
Students' self-assessed confidence levels after completing the course, measured on a 1-10 scale.
Feedback on the clarity and effectiveness of code examples provided throughout the course.
Students' feelings after interacting with peers from other electives, highlighting cross-disciplinary learning value.
How this elective compares to other courses in terms of difficulty, engagement, and educational value.
Students' experiences with receiving support and assistance when needed during the course.
Students' reflections on whether their expectations were met, exceeded, or not achieved based on prior knowledge.
Final reflections and takeaways at the course conclusion, summarizing end-of-course perspectives.
Unique elements of the course that were particularly appreciated, highlighting innovative aspects.
Course elements that, while absent, were noted as positive omissions by students.
Areas where students felt content could have been expanded or covered more thoroughly.
Common course elements deliberately excluded here, to students' appreciation.
Comprehensive overview of learning outcomes and knowledge gained from the course.
Elements that students found demotivating or challenging during the course.
Course elements perceived as unnecessary or less valuable by students.
Constructive feedback on how the course could be enhanced for future iterations.
Specific suggestions for content to add or remove from the course curriculum.
Topics that students felt were not relevant to the course objectives.
Students' assessment of Timur's technical knowledge and teaching expertise.
Feedback on Timur's English proficiency and its impact on the learning experience.
Comparison of Timur's teaching methodology with other instructors' approaches.
Detailed recommendations from students about the course and their learning experience.
Students' aspirations and plans developed as a result of their course learnings.
Students' commitments and promises inspired by their course achievements.
Grade Summary:
- A Grades: 57 students (63.3%)
- B Grades: 28 students (31.1%)
- C Grades: 2 students (2.2%)
- D Grades: 3 students (3.3%)
- Total Students: 90
For detailed analysis, the complete feedback data is available in JSON format.
This course material is licensed under MIT License - see LICENSE for details.