This curriculum is designed for beginners in software engineering and development to build basic technical skills, while providing an introduction to some of the common domains in the field. At amFOSS, we use the curriculum to provide new members with a general overview before they are encouraged to identify a domain of interest to explore in depth. This learning path primarily follows a practical, task-based approach, encouraging its users to pick up new knowledge and skills on the way to completing each challenge.
-
Create a public GitHub repository named
amfoss-curriculum. -
Create directories titled
task-##(where##is the task's serial number) to upload your work for each corresponding task. -
Include a brief explanation in the
README.mdfile within each task folder that portrays your approach to the task and also share your review of the task.
| Task No. | Task Name |
|---|---|
| 00 | Codeforces |
| 01 | Git |
| 02 | Understanding the Foundations |
| 03 | Web Dev Basics |
| 04 | Not a SRS Doc |
| 05 | Wireframe the Skeleton |
| 06 | Figma Design Task |
| 07 | Frontend Development |
| 08 | Backend Development |
| 09 | Flutter Development |
Why Competitive Programming:
Taking on short-term challenges offers significant benefits by pushing you out of your comfort zone, encouraging rapid learning, and reinforcing old skills. Unlike self-chosen projects, where it's tempting to stick with familiar technologies and avoid difficult problems, these challenges force you to confront new and complex tasks directly, leading to real growth and improvement in your abilities.
Codeforces is a competitive programming platform that hosts contests, problem sets, and educational resources, helping users enhance their algorithmic and problem-solving skills. It features a rating system that motivates programmers to improve and engage with a global community through discussions and shared solutions. Codeforces is widely used by students, professionals, and anyone looking to sharpen their coding abilities and prepare for technical challenges.
Approach:
- Every weekend, practice the latest problems in your rating range and time yourself when doing them.
- After you finish a problem, make sure you reflect on the techniques and mindset used and how you could generalize the thought process to solve other problems more efficiently.
- To practice thinking on your do Codeforces live contests and challenge yourself to solve as many problems as you can in the time frame.
Objectives:
- Solve as many problem statements rated 1400 or under.
- Upon solving each problem add its code with the problem's title as the filename. Also, upload your Codeforces profile link.
Outcomes:
- Aim to elevate your rating to 1400+ (i.e., get into cyan rating).
Duration: Until the objectives are met
In this task, we will explore Git, mastering commands that range from the basics to more advanced operations.
Git exercises is a great exercise platform to help you learn and practice Git and discover its features you might not have been aware of.
Additionally, learn git branching provides an interactive way to learn Git through Git graphs, offering visual and hands-on practice with branching, merging, rebasing, and other Git concepts.
Objectives:
- Complete all exercises in Git exercises and take a screenshot of the congratulatory page and upload it to your repository.
- Write a blog about this task, detailing your solutions to each exercise with necessary explanations. The structure is somewhat open-ended; you can write a summary on GitHub Gist, publish a blog on Medium, or even post it on your personal website. This can be the same or a different blog/write-up for each (learn git branching and git exercises).
Outcomes:
- Gain hands-on experience with Git commands, from basic to advanced operations.
- Develop problem-solving skills and discover lesser-known Git features.
- Learn to analyze and utilize resources like documentation and skills like 'googling'.
- Improve technical writing and documentation skills.
Duration: 5 days
In this task, you will establish a solid foundation in programming by learning C. Learning C is crucial because it serves as a foundation for many programming languages, helping you grasp fundamental concepts like memory management and data structures. Your objective is to develop a basic text editor that provides practical experience in applying these fundamental programming principles.
Topics to learn:
- Basic Syntax: Rules, procedural programming, and structure of C programs.
- Variables: Types, mutability, and constants in C.
- Arrays: 1D, 2D arrays, and basic operations.
- Conditionals: if, else, and switch statements.
- Strings: Initialization, concatenation, slicing, and comparison using string functions.
- Loops: for, while, do-while, and break statements.
- Keywords: static, const, and extern.
- Functions: Declaration, recursion, pass-by-value, and pass-by-reference using pointers.
- Pointers: Basics, NULL pointers, pointer arithmetic, and dereferencing.
- Structures: Declaration and usage of structs.
- Memory Management: Dynamic memory allocation using malloc, calloc, realloc, and free.
- Data Structures: Implementing Stack, and Linked List using pointers and arrays.
- File Handling: Reading from and writing to files using fopen, fclose, fread, fwrite.
- Preprocessor Directives: Macros, #include, #define, and conditional compilation.
- Bitwise Operations: Using bitwise operators like &, |, ^, ~, <<, and >>.
- Error Handling: Using errno, perror, and handling function return values.
Objective:
Make a basic text editor with the following features:
- Creating a file
- Read/view the contents of a file
- Update the contents of the file
- Save the file
- Search text
- Navigation using keyboard
- Copy, Paste
- Undo, redo
- Syntax Highlighting (Can be just for .C files)
- Status bar, Message bar, etc. If you want.
- Upon completion, upload the text editor's code to your repository.
Duration: 16 Days
With Div_It_Up Repository develop a strong foundation in web development through projects, quizzes, discussions, and practical assignments and Git as well.
Objectives:
- Begin each lesson with a pre-lecture quiz to assess your current knowledge.
- Dive into the lecture material to explore each subtopic in detail, engage in interactive activities, and reinforce your learning with a post-lecture quiz.
- After completing each lesson, work on the assignment to apply what you've learned.
- Also focuses on component-based coding to help you understand how to structure applications with reusable components.
- Only the best solutions for each task will be merged into this repository. Detailed submission instructions can be found in the README.md, Rubrics for each subtask will be available in the repository.
- Upon completion add a README to your solution repository with this fork's link.
Outcomes:
- Gain a thorough understanding of core web development concepts and apply them through hands-on projects.
- Demonstrate proficiency in event-driven programming, managing state, manipulating the DOM, implementing routing, and using components effectively in web applications.
- Enhance your problem-solving skills with practical assignments and quizzes, and have the opportunity to showcase your best work by having your solutions featured in the repository.
- Familiarize yourself with component-based coding, learning how to create, manage, and reuse components effectively in web development projects.
Deadline: 10 days
There is a journey behind every application or website we see, popularly known as the development cycle.
- The development cycle begins with creating an SRS document, which outlines the project's requirements and goals. Creating a proper SRS document is beyond the scope of this curriculum, although you will be making a much smaller version of it here.
- Next, wireframes are developed using tools like Moqups or Figma to establish the basic layout and structure of the website.
- The wireframes are then translated into detailed visual designs using Figma, focusing on the look and feel (UI and UX).
- Following this, front-end and back-end development are carried out, with the front-end handling the user interface and the back-end managing data and server logic.
- Finally, both are integrated to ensure seamless interaction between the user interface and the underlying systems.
The following is the list of features that should be included in the website you make and the important points to remember while working on such a project. After reading these, you can continue with task 04, where you will start working on this website by doing the first step, that is, creating an SRS document!
The website you are gonna create:
Letterboxd is a social networking platform for film enthusiasts where users can discover, rate, and review films, as well as interact with a community of like-minded people. It allows users to create watchlists, log films they've watched, and write reviews. Additionally, it offers curated lists, film recommendations, and the ability to follow other users to see their activity. Visit the site : Letterboxd
Features to Adopt for a Similar Website:
1. User Authentication:
Sign-up, sign-in, and social media login.
2. Search Functionality:
Search for tasks (or your chosen subject) by title, genre, date, etc.
3. Task/Item Addition:
Users can add new tasks or items (like new movies) with details like description, images, and categories.
4. Review and Rating System:
Users can write reviews, rate tasks, and edit or delete their reviews. Remember, other users can review the tasks/items/movies you have created, just like you can rate the ones they have created.
5. Watchlist/Task List:
Users can create and manage lists of tasks to complete or review later.
6. Social Features:
Follow other users, view their activity, and comment on their reviews.
7. Recommendations:
Suggest similar tasks based on user preferences or genre.
8. Curated Lists:
Featured lists curated by the website or users highlighting specific themes or categories.
These features will help create a rich, interactive platform similar to Letterboxd but tailored to your specific subject.
Now we don’t expect you to complete all these features. But try as hard as you can.
1. Clean Code
Code should be well-structured, readable, and maintainable, following best practices like proper naming conventions, consistent formatting, and meaningful comments.
2. Architecture and Design
The project should follow a well-defined architectural pattern that separates concerns, promotes modularity, and supports scalability. Research the most popular approach and follow it.
3. Functionality and Completeness
All required features (e.g., user authentication, task addition, reviews) should be implemented and working as specified, covering both core and additional functionalities.
4. User Experience (UX) Design
The interface should be designed to provide a smooth, intuitive, and user-friendly experience. The flow of the app should be clear and consistent for users.
5. Responsible Use of AI Tools
While AI tools can assist with code generation, a significant portion of the project should showcase your own understanding and problem-solving skills. Over-reliance on AI should be avoided, and manually written code should reflect thoughtful design and learning.
From here on till the completion of the next five tasks (i.e., tasks 4-8) all the tasks will be related to the Letterboxd-inspired project.
A Requirements document is a simple and clear description of what a software project aims to achieve. It covers essential elements like key features, user needs, and basic design guidelines to provide a shared understanding among developers, designers, and stakeholders. It's an essential first step to align everyone involved in the project.
Objectives:
- Create a very basic version of a SRS document for the above project (Letterboxd).
- Upon completion, upload the SRS document to your repository.
Outcomes:
- Gain a foundational understanding of how to draft a requirements document.
- Learn how to outline project goals, scope, and expectations effectively.
- Encourage a structured approach to planning and documenting software requirements.
- Develop the ability to identify and document essential software requirements.
- Build confidence in creating initial project documents for alignment and clarity.
Duration: 3 days
Wireframes are basically skeletons for designs. They act as a blueprint for the design and development phases, providing clarity and direction. The designs are built over the wireframes.
Wireframe Mobile example
Objectives:
- Create wireframes for both the website and mobile view of the project using Figma or Moqups. (Moqups has a limit on its free edition, so feel free to use plugins or libraries in Figma to complete the task.)
- Upon completion, upload the wireframe or the Figma project link to your repository.
Outcomes:
- Gain hands-on experience in creating wireframes for different device views.
- Develop an understanding of user flow, content placement, and key design principles, including responsiveness, user experience, etc.
- Build confidence in using design tools and techniques for initial project planning like Figma or Moqups.
Duration: 5 days
Now that you've created the wireframes for the website and mobile views, it's time to bring those ideas to life with Figma. This is where your project starts to feel real, as you add color, style, and interactions that make the design engaging and user-friendly. Start with the website (desktop view), once you're happy with how these look, adapt the design for mobile.
Objectives:
- Transform initial wireframes into fully designed website and mobile views using Figma.
- Upon completion, upload your Figma project link to your repository.
Outcomes:
- Develop an eye for visual consistency, usability, and user-centric design principles.
- Improve skills in designing responsive layouts that adapt well to different screen sizes.
- Learn to design key website pages, such as the homepage, user profile, and task/item detail pages, for both desktop and mobile.
Duration: 7 days
The front end of a website is the part that users interact with directly. It involves designing and building the user interface (UI), which includes everything from the layout and design to the buttons and forms. A well-crafted frontend ensures a seamless and enjoyable user experience.
Next.js is a popular React framework(React is a JS library) that enables developers to build fast, scalable, and SEO-friendly web applications.
Objectives:
- Create a frontend for the Letterboxd-like project you are doing, using Next.js.
- Upon completion, upload all the necessary files except node_modules folder to your repository.
Outcomes:
- Acquire practical skills in building a complete frontend for a web application using Next.js.
- Develop the ability to create a responsive and interactive user interface that enhances user experience.
- Gain experience in preparing and structuring the frontend to seamlessly integrate with dynamic data and APIs.
Important things to note
Track Hardcoded Values: Make a list of all the fields where you're using hardcoded values during the frontend development. This will help you know exactly where to replace them with API data during the backend integration.
Prepare for Integration: Ensure that the frontend structure is flexible and ready to accommodate dynamic data, making the integration process smoother and more efficient.
This approach ensures that the frontend development is aligned with future backend integration, leading to a cohesive and functional final product.
Deadline: 12 days
The backend is a server-side codebase that handles and manages all your data behind the scenes.
Now, you need to build a backend for the Letterboxd-like app you're developing using Flask and REST APIs. This includes implementing all the necessary endpoints, as well as managing the application logic. When used together, Flask can serve as the web framework to handle requests, while REST APIs can be implemented to manage data interactions. This combination provides a robust foundation for creating flexible and scalable backends.
Objectives:
- Develop a backend using Flask and REST APIs.
- Focus on building essential endpoints and managing application logic.
- Upon completion, upload all the necessary files to your repository.
Outcomes:
- Gain practical experience in building a backend with Flask, enhancing skills in server-side development.
- Understand how Flask serves as a web framework for handling requests, while REST APIs facilitate data interactions.
- Learn to implement RESTful principles for creating, reading, updating, and deleting (CRUD) operations within the application.
- Develop the ability to manage application logic effectively, ensuring efficient data handling and processing.
Deadline: 12 days
The web development tasks are completed! We hope that learning how to build a functional website was exciting. Next, we will explore the domain of mobile development and get started with some hands-on experience.
Flutter is an open-source UI software development toolkit created by Google. It is used to develop applications for various platforms, including Android, iOS, Linux, macOS, Windows, and the web, from a single codebase.
Objectives:
You are tasked with building a Pokédex app using Flutter with the following features:
- Search Page: Users can easily search for Pokémon by name or other attributes.
- All Pokémon Page: Display a list of all Pokémon with options to sort and filter based on stats and abilities.
- Trading: Allow users to trade Pokémon with friends and other users.
- Random Pokémon: Each user receives a random Pokémon upon installing the app.
- Capture Pokémon: Users can capture additional Pokémon by playing a silhouette-based guessing game. Example Video
- Backend: Create a backend system to manage Pokémon trading, friends, and the silhouette quiz game.
- Animations and Transforms: Incorporate various animations and transformations including Flutter’s Hero animation, to enhance the user experience.
Outcomes:
- Practical Experience: Gain hands-on experience in developing a comprehensive mobile app using Flutter, including front-end design and backend integration.
- Feature Implementation: Successfully implement and integrate core features like search, sorting, trading, random Pokémon, and capture games, ensuring functionality and usability.
- Enhanced UI/UX: Develop skills in creating a visually appealing and interactive user interface with advanced animations and transformations.
- Backend Development: Acquire knowledge in setting up and managing a backend system to support app functionalities, including user data management and game logic.
Don't forget to follow the 'Points to Ponder' shared earlier.
Deadline: 10 days
You are all done! We wish you all the best on your software development journey. Feel free to inform your mentors about what you enjoyed, what you didn’t enjoy, what you wished it had more, what topics you wished it had incorporated more, and so on in regards to the curriculum. Your feedback is vital and always appreciated.
To explore further into various domains, check out the resources.md