By refining the Feature Auction to 5 balanced options and allowing teams to pick just one, we aim to provide a fair and manageable challenge that enables participants to demonstrate their Rust skills effectively. Adjusting the expectations around performance ensures that teams can focus on writing efficient and maintainable code without undue pressure to achieve unrealistic benchmarks within the limited timeframe.
Choose a feature that interests you and aligns with your strengths. Focus on delivering a well-crafted solution that you can be proud of. Good luck, and happy coding!
Choose a feature that interests you and aligns with your strengths. Focus on delivering a well-crafted solution that you can be proud of. Good luck, and happy coding!
20— 24
By refining the Feature Auction to 5 balanced options and allowing teams to pick just one, we aim to provide a fair and manageable challenge that enables participants to demonstrate their Rust skills effectively. Adjusting the expectations around performance ensures that teams can focus on writing efficient and maintainable code without undue pressure to achieve unrealistic benchmarks within the limited timeframe.
Choose a feature that interests you and aligns with your strengths. Focus on delivering a well-crafted solution that you can be proud of. Good luck, and happy coding!
Choose a feature that interests you and aligns with your strengths. Focus on delivering a well-crafted solution that you can be proud of. Good luck, and happy coding!
Challenge
Build a high-perf URL shortener to show off modern Rust capabilities & efficient system design — focus on language implementation excellence whlist keeping the code minimal but functional.
Core
Feature Auction
In addition to the main challenge, we’ve introduced a Feature Auction. Below is a list of 5 balanced features. Each team must choose 1 feature to implement in their project. Pick a feature that best highlight your skills and enhances your URL shortener.
New Twist
- Encrypt stored URLs to enhance security and protect user data.
- Demonstrates use of cryptographic libraries and secure coding practices.
05
Data Encryption
- Provide a minimal RESTful API for programmatic access to the URL shortener.
- Involves designing and implementing HTTP endpoints.
04
API Access
- Automatically generate QR codes for each shortened URL.
- Utilizes image generation libraries and binary data handling.
03
QR Code Generation
- Enable URLs to expire after a certain date or number of uses.
- Involves time-based functionality and data management.
02
Expiration Dates
01
Custom URL Aliases
- Allow users to create custom shortened URLs
- Demonstrates user input handling and validation.
PICK JUST ONE ⇲
Feature List
- Encrypt stored URLs to enhance security and protect user data.
- Demonstrates use of cryptographic libraries and secure coding practices.
05
Data Encryption
- Provide a minimal RESTful API for programmatic access to the URL shortener.
- Involves designing and implementing HTTP endpoints.
04
API Access
- Automatically generate QR codes for each shortened URL.
- Utilizes image generation libraries and binary data handling.
03
QR Code Generation
- Enable URLs to expire after a certain date or number of uses.
- Involves time-based functionality and data management.
02
Expiration Dates
- Allow users to create custom shortened URLs (e.g., `yourdomain.com/customalias`).
- Demonstrates user input handling and validation.
01
Custom URL Aliases
Choose 1 ⇲
Feature List
Areas
Evaluation
- Thoughtful choice of crates
- Appropriate use of async where beneficial
- Storage integration
- Minimal dependencies
- Integration of modern tooling
MAIN FOCUS
Ecosystem Usage
- Use of modern Rust idioms and patterns
- Effective utilization of the type system
- Robust error handling
- Concurrency where appropriate
- Memory safety and management
Language Mastery
1. Modern [Rust] CODING —
- Practical optimizations
- Efficient data structures
- Avoidance of common bottlenecks
- Reasonable resource usage
GOOD TO HAVE
Performance Awareness
- Clean and modular architecture
- Organized data flow
- Efficient resource management
- Scalable design considerations
- Maintainability
Design Principles
2. System Architecture —
The interface should be just enough to demonstrate the system’s capabilities.
Keep IT Simple
- Minimal HTTP API endpoints
- Basic CLI tool
- Single-page form interface
Choose ONE:
3. USER Interface/EXPERIENCE —
- Concurrent request handling where applicable
- Efficient storage usage
- Resource management
- Code readability and maintainability
GENERAL RECOMMENDATION
Technical Requirements
- URL shortening
- Redirect handling
- Persistence
- Basic error handling
Core Functionality
4. Core FEATURES —
5. Auction Feature —
Implement the one feature you selected from the Feature Auction list, integrating it BLASSINGLY FAST into your project.
PICK ONE AND IMPLEMENT
Innovative & CREATIVE
- Thoughtful use of Rust features
- Clever technical solutions
- Practical optimizations
- Unique approaches
6. TRY TO be —
What Makes a Great Project
Good Implementation
- Functional Rust code
- Working features
- Simple but clean code
- Demonstrable system
- Attempted implementation of the selected feature
Outstanding Implementation
- Idiomatic use of Rust features
- Clean and maintainable code
- Effective error handling
- Thoughtful technical decisions
- Seamless integration of the selected feature
Strong Implementation
- Good use of Rust patterns
- Solid architectural design
- Effective type system use
- Clear technical choices
- Successful implementation of the selected feature
Blazingly
Blazingly
Areas
Focus
— Complex UI/UX
— Extensive documentation
— Perfect test coverage
— Production deployment
— Complex configurations
— Multiple interfaces
— Detailed API docs
— Extensive documentation
— Perfect test coverage
— Production deployment
— Complex configurations
— Multiple interfaces
— Detailed API docs
Focus On
Focus On
DO
DON'T
Realistic Expectations
We understand that achieving top-tier performance within a 72-hour can be challenging. While performance considerations are part of the evaluation, the emphasis is on practical and reasonable optimizations rather than achieving extreme industry benchmarks.
Focus on:
+ Code efficiently where it's needed
+ Avoid obvious perf pitfalls
+ Show awareness in your decisions
+ Avoid obvious perf pitfalls
+ Show awareness in your decisions
~ Clean code beats micro-optimization.
experts
Judges
Lead Mobile Engineer with 10+ years of expertise in innovative Android solutions, IoT applications, and enterprise-grade software, driving startup growth and transformative technologies
United States of America
Kauslendra Tripathi
Experienced healthcare IT leader with nearly two decades of expertise in data interoperability, AI, cybersecurity, and driving impactful innovations for patient care and societal benefit
United States of America
SADHASIVAM MOHANADAS
Transforming monolithic systems to microservices and improving system reliability at scale
Cyprus
Alexandr Hacicheant
Global AI/ML leader driving innovation, transformation, and societal impact across industries
United States of America
Balaji Dhamodharan
Innovative software developer with 12+ years of expertise in web development, AI/ML, and cloud technologies, driving transformative business solutions
United States of America
Bharat Vishal Tiwary
Strategy
72-Hour
Day 4 [03.02]:
- Complete the UI
- Refine code and fix bugs
- Conduct performance checks
- Prepare the presentation and demo
- System testing and validation
Polish & Demo Preparation
Day 1 [31.01]:
- Project setup
- Core data structures
- Basic functionality
- Storage integration
- Choose 1 feature from the Feature Auction
Core Implementation
Day 2 - 3:
- Implement the selected feature
- Improve error handling
- Optimize data flow
- Begin UI development
Feature Integration & Enhancements
[5-7 minutes]
Show your URL shortener in action, highlighting core and additional functionalities.
6 — Live Demonstration
Present any optimizations and how they impact performance in a practical sense.
4 — Performance Considerations
Demonstrate the additional feature you implemented from the Feature Auction.
5 — Selected Feature Demonstration
Presentation
Explain why you chose certain libraries, patterns, and data structures.
3 — Technical Decisions
Discuss your system’s design and how it supports the core functionality and selected feature.
1 — Architecture Overview
Showcase interesting aspects of your Rust code, including language features and idioms used.
2 — Rust Implementation Highlights
prizes
200$
+ PACKT'S BOOK
3rd
2nd
+ JETBRAINS "ALL PRODUCT PACK"
300$
1st
+ featured showcase on media
1000$
Tips for Success
Tips for Success
for Success
Tips
+ Be prepared to explain and justify your technical and design decisions.
5. Be Ready to Discuss Your Choices
+ Write clean, readable, and idiomatic Rust code that others can understand and maintain.
1. Prioritize Code Quality
+ Fully integrate and test the feature you choose from the auction.
2. Implement the Selected Feature Well
+ Ensure your interface is functional and user-friendly, even if it’s minimal.
3. Keep Interfaces Simple
+ Practice your demo to showcase your system effectively without unnecessary details.
4. Prepare a Focused Demonstration
Panel
We bring together top-tier experts from leading tech companies worldwide to evaluate projects at our events. Our panel and carefully structured multi-staged evaluation process guarantee thorough assessments.
Expert
Emphasis
Judging
+ Rust Implementation
+ Use of Language Features
+ Technical Design Decisions
+ Practical Performance Considerations
+ Working Demonstration
+ Creativity in Approach
+ Integration of the Selected Feature
+ Use of Language Features
+ Technical Design Decisions
+ Practical Performance Considerations
+ Working Demonstration
+ Creativity in Approach
+ Integration of the Selected Feature
Choose a feature that interests you and aligns with your strengths. Focus on delivering a well-crafted solution that you can be proud of. Good luck, and happy coding!
Organized and designed by raptors.dev.
Blazingly Fast URL Shortener Challenge
By refining the Feature Auction to 5 balanced options and allowing teams to pick just one, we aim to provide a fair and manageable challenge that enables participants to demonstrate their Rust skills effectively. Adjusting the expectations around performance ensures that teams can focus on writing efficient and maintainable code without undue pressure to achieve unrealistic benchmarks within the limited timeframe.
