Open-Source: Week 1
It is great to write again this week. This blog post is going to talk about the key things that I have been learning in order to make a successful open source contribution. The first thing I did was to analyze an article called “Contributing to open source on Github”, I found this article fascinating, that's why I would like to share my keynotes on that article, just in case you want to navigate over that information but going through this summary.
Before jumping into my summary, I would like to add some ideas I found interesting to motivate others to contribute in open source.
- Learn new skills.
- Grow your network by meeting new people.
- Learn about real-world applications.
- Create the habit of cooperation, helping, and learning.
Bellow, I present my notes.
Why contribute to open source?
- Improve the software you rely on.
- Improve existing skills.
- Meet people who are interested in similar things.
- Find mentors and teach others.
Build public artifacts that help you grow a reputation and a career
- By definition, all of your open source work is public, which means you get free examples to take anywhere as a demonstration of what you can do.
- Learn people skills.
- It’s empowering to be able to make changes, even small ones.
What does it mean to contribute?
- You don’t have to contribute code (in this phase for the academy program we do have to contribute code).
- Do you like planning events?
- Do you like to design?
- Do you like to write?
- Do you like organizing?
Do you like to code?
- Ask if you can help write a new feature.
- Automate project setup.
- Improve tooling and testing.
Do you like helping people?
- Answer questions about the project on Stack Overflow or other platforms.
- Answer questions for people on open issues.
- Help moderate the discussion boards or conversation channels.
- Do you like helping others code?
Orienting yourself to a new project
Anatomy of an open-source project
- Author: Who created the project.
- Owner: Who has administrative ownership.
- Maintainers: Contributors who manage the organization.
- Contributors: Everyone who has contributed.
- Community members: People who use the project.
- License: Must be an open-source license.
- Readme: Instruction manual, why the project is useful, and get started.
- Contributing: This document helps people to contribute, and explains the process.
- Code of conduct: Ground rules for participants.
- Other documentation: Tutorials, walkthroughs, or governance policies.
Tools to organize discussion
- Issue tracker: Where people discuss issues.
- Pull requests: Where people discuss and review changes in progress.
- Discussion forums or mailing lists: For conversational topics.
- Synchronous chat channel: Casual conversation, collaboration, and quick exchanges.
Finding a project to contribute to
A checklist before you contribute
- Meets the definition of open source: License.
- Actively accepts contributions: Commit activity of the master branch.
- Latest commit.
- How many contributors?
- How often do people commit?
- How many open issues are there?
- Maintainers respond quickly to issues?
- Active discussion on the issues?
- are the issues recent?
- are issues getting closed?
Project’s pull requests
- How many open pull requests are there?
- Do maintainers respond quickly to pool requests?
- Is there active discussion?
- Are pull requests recent?
- How recently were any pull requests merged?
Project is welcoming
- Maintainers respond helpfully to questions in issues.
- Are people friendly?
- Do pull requests get reviewed?
- Does the maintainer thank people for their contributions?
How to submit a contribution
- Give context: Explain your problem, how to reproduce it If you are suggesting an idea, explain how that idea would be useful to the project.
- Do your homework beforehand: Show that you tried before asking for help.
- Keep requests short and direct: Be concise.
- Keep all communication public.
- It’s ok to ask questions but be patient.
- Respect community decisions.
- Above all keep it classy.
- Before doing anything, do a quick check to make sure your idea hasn’t been discussed elsewhere.
- Issues are like starting a conversation or discussion.
- Pull requests are for starting work on a solution.
- For lightweight communication, such as a clarifying or how-to question, try asking on other chat channels, if the project has one.
Opening an issue
- Report errors.
- Discuss a high-level topic.
- Propose a new feature or project idea.
Opening a pull request
- Submit trivial fixes.
- Start working on a contribution that was already asked for.
- You can submit early your pull request and add WIP (work in progress) so people can see your progress.
- Create a branch for your edits.
- Reference relevant issues.
- Include screenshots of the before and after.
- Test your changes!
- Contribute to the style of the project: Comments, syntaxis, etc.
What happens after you submit a contribution
- You don’t get a response: Check the project for signs of activity.
- Someone requests changes to your contribution.
- Your contribution doesn’t get accepted.
- Your contribution gets accepted.
My learning of CS concepts
I would like to add this section to introduce some things that I studied to be prepared for future opportunities, I hope you find this helpful too:
Abstract data types: (ADT) is the specification of a group of operations that make sense for a given data type. Describes how variables of a given data type are operated.
Examples: Stack, Queue, Priority Queue, List, Sorted List, Sorted List, Map, Set.
Describe how data is to be organized and accessed in the computer’s memory. There are different ways to implement ADTs because there are different data structures.
- Select an ADT implementation that uses the best data structure according to your needs is essential for creating efficient computer programs.
- The array is the simplest way to store a bunch of items in computer memory.
- Consists of allocating a sequential space in the computer memory, and writing your items sequentially in that space, marking the end with a special NULL token.
- Each object in an array occupies the same amount of space in memory.
- The array is useful for implementing the Stack, but can also be used to implement Lists and Queues.
- Instant access time.
- When allocating large amounts of sequential space in memory. There might not be enough free space adjacent.
- Removing an item in the middle is problematic.
- Adding an item causes you to push all subsequent items one step forward.
The Linked List
- In a Linked List Items are stored in a chain of cells that don’t need to be at sequential memory addresses. Memory for each cell is allocated as needed.
- Each cell has a pointer indicating the address of the next cell in the chain. A cell with an empty pointer marks the end of the chain.
- Can be used to implement Stacks, Lists, and Queues.
The advantage over the array:
- There is no problem growing the list since each cell can be kept at any part of the memory.
- We can create Lists as big as the amount of free memory.
- It’s easy to insert items in the middle or delete any item by changing the cell pointers.
- We can’t instantly retrieve the nth item. We have to start searching at the first cell, use it to get the address to the second cell, then get to the second cell, use its pointer to the next cell, and so on.
- If we’re only given the address of a single cell, it’s not easy to remove it or move backward. With no other info, we can’t know the address of the previous cell.
The Double Linked List
- The Double Linked List is the Linked List but with an extra, cells now have 2 pointers: One to the cell that came before it, and the other to the cell that comes after.
Same benefits as the Linked List:
- No big chunk of memory preallocation is required, memory space for new cells can be allocated on demand.
- The extra pointers allow us to walk the chain of cells forwards and backward.
- The last point means that if we are given the address of a single cell, we’re able to delete it.
- There’s no way to access the nth item instantly.
- Storing 2 pointers translates to more code complexity and more required memory to store our data.
Arrays vs. Linked Lists
Linked Lists are preferable to Arrays when:
- You need insertions and deletions to be extremely fast.
- You don’t need random, unordered access to data.
- You insert or delete items in the middle of a list.
- You can’t evaluate the exact size of the list (it needs to grow or shrink throughout the execution).
- This is possible thanks to the fact that memory allocation doesn’t need to be sequential.
Arrays are preferable over Linked Lists when:
- You frequently need random, unordered access to the data.
- You need extreme performance to access the items.
- The number of items doesn’t change over the execution so you can allocate contiguous space of memory.
Thank you for reading!