DEV Community: Ida Delphine

Building Thriving Communities from Scratch: A Step-by-Step Guide

Ida Delphine — Sun, 21 Apr 2024 22:55:46 +0000

In today's increasingly connected world, communities are more than just groups of people with shared interests; they're vibrant ecosystems that foster connection, collaboration, and growth. But building a community from scratch, one that thrives and endures, requires more than just throwing people together. It's a strategic endeavor that demands patience, dedication, and a well-defined roadmap.

The Foundation: Purpose and People

Every thriving community is built on a solid foundation of purpose. This purpose serves as the North Star, guiding the community's direction and motivating its members. It could be a shared passion for woodworking, a desire to support aspiring entrepreneurs, or a commitment to environmental sustainability. Clearly define your purpose early on, and ensure it resonates with your target audience.

Building the Team: Diverse Skills, Shared Vision

Assembling a strong organizing team is crucial. Look for individuals with complementary skillsets, from event planning and social media management to content creation and design. But beyond technical expertise, prioritize those who share your community's vision and are passionate about fostering its growth.

Establishing the Hub: Where Your Community Connects

Choosing the right communication platform is essential. Consider the demographics of your target audience. Will a platform like Discord resonate more with a gaming community, or would a professional network like LinkedIn be a better fit for a business-oriented group? Whichever platform you choose, ensure consistency – use the same username across all social media channels to make it easy for people to find you.

Growing Your Community: Strategic Outreach

Targeted outreach is key to attracting the right members. If you're building a community for aspiring writers, connect with creative writing programs at universities. For a community focused on fitness, partner with local gyms or health clubs. Explore various outreach methods – social media campaigns, guest lectures at relevant events, or even community radio announcements – and track which tactics yield the best results.

Nurturing the Ecosystem: Engagement is Key

Once members join, make them feel welcome. Clearly outline community guidelines and encourage them to invite others who might share your vision. But building a community goes beyond mere numbers. Active engagement is the lifeblood of any thriving community. Here's where your content strategy comes in.

Content is King: Providing Value to Your Members

Develop a content calendar that aligns with your community's purpose. This could include insightful blog posts, informative webinars, or interactive workshops. Encourage member participation through discussions, Q&A sessions, and collaborative projects. Remember, the goal is to provide value and keep members engaged in a meaningful way.

Building Momentum: A Culture of Collaboration

Plan events that resonate with your members' interests. Host meetups, online workshops, or even hackathons that address challenges relevant to your community's purpose. Remember, it's not just about you – empower your members to take ownership. Foster a culture of collaboration where members can share their expertise, mentor each other, and contribute to the community's growth.

Sustainability: Tracking, Analysis, and Adaptation

Track your progress using the KPIs you established with your team. Analyze these metrics regularly to identify what's working and where you can improve. Be prepared to adapt your strategy based on your findings.

The Power of Partnership: Collaboration for Impact

Building strong relationships with other communities in your niche can be mutually beneficial. Explore opportunities for collaboration, such as co-hosting events or cross-promotion. This not only expands your reach but also fosters a sense of connection within the broader ecosystem.

Building a Legacy: Succession Planning

To ensure the long-term sustainability of your community, consider developing a succession plan. Identify and cultivate passionate members who can step up and take on leadership roles when needed. This ensures your community continues to thrive, even as its core team evolves.

Building a thriving community is a journey, not a destination. By following these steps, fostering a welcoming and engaging environment, and constantly adapting to your members' needs, you can cultivate a space where connection, collaboration, and shared purpose flourish.

Generative AI & Gemini

Ida Delphine — Sun, 14 Apr 2024 20:15:18 +0000

What is Generative AI?

Generative AI has become very popular lately where its being used by the masses to generate different types of content ranging from text, images, videos, etc. Generative AI is a subset of artificial intelligence (AI) techniques that focus on generating new, original content based on input data or patterns learned from existing data. Unlike traditional AI models that are designed for specific tasks such as classification or prediction, generative AI models are capable of creating entirely new data samples that resemble the training data they were exposed to. It makes the uses of generative models which generate new content based on a learned probability distribution of existing data.

What is Gemini?

Gemini is a LLM (large language model) developed by Google Deepmind capable of generating text, translating language and writing all sorts of creative content. It is multimodal in the sense that it can understand a wide range of information ranging from text,audio, images, etc and provide output accordingly.

Visit here to try out it's capabilities.

I know this article is short. In the next we will be building a generative AI application with the Gemini API

React's virtual DOM explained

Ida Delphine — Sun, 07 Apr 2024 21:16:37 +0000

React is an opensource JavaScript library which is used to build web interfaces using components. What makes React really cool is the fact that it can be used to make re-usable components. In addition, it is very flexible and has a huge community.

As a web developer, the DOM (Document Object Model) should not be a new concept. But to refresh your memory, the DOM basically represents a web page in a hierarchical tree-like structure. This web page is also known as a document and it is kinda an object-oriented representation of the web page. You really get to appreciate the DOM when you try to incorporate certain functionalities into your web page or manipulate it with JavaScript. Through the DOM, you can target specific HTML elements and modify them accordingly. The DOM was built using an API which makes it language agnostic. This means you must not necessarily use JavaScript to manipulate it.

Every React developer should understand what the virtual DOM entails. Usually, rendering a web page is fast. But when the DOM is manipulated where a specific item changes, the entire webpage is re-rendered which kind of slows everything down. This is where the virtual DOM comes in. The virtual DOM is a lighter abstraction of the DOM which is saved somewhere in the browser's memory. The virtual DOM does not replace the real DOM. It aids in making the rendering of web pages more efficient. The state you want the UI to be is first specified and when changes are made to the virtual DOM, it compares it with the changes just before it was updated. Once the element that was changed is identified, only that element is targeted and updated on the real DOM. Without the virtual DOM, the entire page could be re-rendered because of a tiny update.

Learn more here.

Getting the Outreachy Internship

Ida Delphine — Sun, 31 Mar 2024 21:41:48 +0000

If you are new to opensource, one of the best and rewarding ways to get your foot in the door or start out is to participate in programs like Outreachy. Especially for students who are looking to build experience and work on real life projects. When you hear "outreachy", think of 3 things; remote, paid and open source/open science. To sum it up, Outreachy is a remote paid internship program aimed at increasing/promoting diversity and inclusion in open source and open science. This internship happens twice a year with one cohort starting in May and the other in December.

How Outreachy works

Outreachy is particularly meant for individuals who belong to underrepresented groups in the field of technology so women are highly encouraged to apply. Interns will have the opportunity to contribute to different opensource projects in different areas like programming, research, user experience, documentation, graphical design, data science, marketing, user advocacy, event planning,etc. So there is definitely something for everyone and this is just to make you understand "open source" is not only limited to code contributions.

For every Outreachy cohort, there are a couple of mentoring opensource organizations with each having specific and detailed projects which the potential intern will work on. The number of project per organization determines the number of interns. For example, it is most likely that if a single mentoring organization has 3 projects, nothing less than 3 interns will be needed for that specific organization. Bare in mind that the various projects may vary in terms or requirements and skill needed. However, they are all designed to be completed within a span of approximately 3 months with 7000 USD to be paid. The intern will work along side their mentors who are experienced contributors in that organization.

Application Procedure

There are 3 major steps to be taken to be considered for the outreachy internship. We have the initial application, contribution phase, and final application.

Initial Application: This is the first step of the application process and it is often taken for granted by many. Here, the outreachy organizers want to know more about your background and understand how both underrepresented and discriminated on you have been and a minority or underrepresented group. You are to write a couple of essays and submit.
Contribution Period: This is the next stage after the initial applications. Once you submit your initial application, the outreachy organisers will review your essays and if they are convincing such that they show you are underrepresented, can commit to 40hrs/week of the internship and passionate, you will be accepted into the contribution phase. I will say this step is the most difficult as you are supposed to find projects that interest you and make as many contributions as you wish to the organisation the project is under. This is the stage where you get to know more about the organization and start exploring it's codebase (if it's programming you are going for). This is also where you get to bond with the community and your potential mentor. You have the choice of picking up to 3 projects you are interested in working on. But know that you will have to make contributions to all the organizations they are under and if you are to be selected as an intern you will only be selected for one.
Final Application: This is the final step of the application process. After you have made contributions, you will have to submit a final application where you will log the contributions you made, provide a road map of how you plan on working on your selected project(s) and provide extra information about you.

Tips and Tricks

Read the entire applicant guide on the outreachy website.
Take your time to answer the questions in your initial application. If you can include some examples of past experiences where necessary that highlight the bias/discrimination you have faced that could help. Also make sure everything about your application proves you will be able to commit 40hrs a week if granted the internship with little or no interruptions from school, work, etc. Finally, try to submit your application latest 1 week before the deadline.
You can also start checking out mentoring organizations before the contribution period. There is a "current projects" page you can checkout which will be updated as days go by with more organizations and projects. On this page you will get to see listed organizations and associated projects. You will see tiny details about the technologies required and skill level. You can use this to your advantage. If you see a project that interests you and your skills match, you can start doing your research and learning about it right before the contribution period. That way when the contribution period officially starts, you should have grasped the basic and gone through their code base.
Make sure you go for a project where most of your skills match.
Focus on contributing to just a single organization and take your time to submit quality over quantity.
Make sure you've joined the community's most active public chat.
Be active within the community and attend all their calls, contribute to their discussions.
Reach out your mentor if you face any difficulty but make sure you have done your research. Work alongside your mentor to come up with the breakdown of your project plan for your final application.
Even after the final application, stick around and still show interest in the community and its activities.

Understanding license compliance in open source projects

Ida Delphine — Sun, 24 Mar 2024 20:13:45 +0000

As an open source contributor, aspiring contributor or maintainer, it is very important to take licences very seriously as they determine how you can interact with any open source project. Open source licences are basically legal agreements which define how open source software should be read, ran, revised and redistributed. For a start, lets talk about the types of opensource licences.

Permissive vs Copyleft licenses

Free and opensource licences can be divided into two main categories - permissive and copyleft.

Permissive licenses: Permissive licenses allow any one to use, modify and redistribute software without any restrictions. It basically means derivatives of such software under this license could be made propriety or closed-source irrespective of the fact that their parent project is opensource. Some examples of such licenses are the MIT, Apache licences.
Copyleft licenses: Copyleft licenses allow you to use,modify and redistribute software however, the software has the changes are shared other same license. This measns the software and its derivatives must remain free and open for everyone to use. Some examples include the GNU GPL licences.You can see that copyleft licenses protect the freedom of downstream users.

You now realize that before starting an open source project or interact with one, it is important to check what license it is under.

Open source license compliance

They say open source software is free but is it really? Are all open source software really free? The "free" part only means you have the freedom to use, modify, and redistribute it. However, the license really determines how you actually utilize these freedoms. This is why we have to understand open source license compliance. You might be wondering what the point might be since there's no active company enforcing it.

First of all, you really want to take license compliance seriously because you wouldn't want to have to deal with any lawsuits or penalties. Remember these licenses are legal contracts which give authorization and permission on how opensource software should be used, modified and distributed. Breaching the terms of this contract could come with some consequences which are not worth it. Compliance goes a very long way to mitigate any legal risks that could pose a threat to organizations. In addition, these licenses protect the intellectual property rights of both the original authors and subsequent contributors and compliance comes in to enforce the intentions of how the original authors intend for their software to be used.It ensures downstream projects abide by the rules of the original authors enforcing their rights. Further more, compliance helps build trust and transparency within a community as everyone is on the same page as per how the software is supposed to be used, modified or distributed. Failure to comply to the licenses might actually break the trust, lead to disputes, and possibly affect the community behind the software negatively.

To conclude, open source license compliance is essential for ensuring legal, ethical, and practical adherence to the terms of open source licenses. It helps protect intellectual property rights, preserve community trust, mitigate legal risks, and promote the principles of openness and collaboration in software development.

Finding an open source project and contributing to it

Ida Delphine — Sun, 17 Mar 2024 17:24:16 +0000

Finding an open source project is one thing and contributing to it is another. What makes a project or anything opensource is the fact that anyone is free to view it, run it, and most importantly revise and share it.Everyone has their reason to getting involved or contributing to open source and there is honestly no wrong reason because any meaningful contribution in whatsoever way goes a long way. If you're in doubt about contributing to open source, below are some great reasons you should consider it.

Benefits of getting involved in opensource

Improve your technical skills
Gain more work experience
Broaden your horizons
More credibility as you can prove your skills
Network with people from different backgrounds
Turn your ideas into life
Build your portfolio

Finding an opensource project

If you do not have any opensource project in mind and are genuinely interested in contributing to open source, I have a tip to share. You can start by thinking about what you love doing. Could be coding, design, writing. Then you look around you; what are those tools or technologies you enjoy using or frequent day to day? Could be Firefox, Wikipedia, Git, VS Code, etc. Find out if they are open source and have a public repository. Another way to find open source projects is to participate in programs like Hacktoberfest, Outreachy, Google Summer of Code, etc. Even if you are not actively participating, you could visit their pages and check out past projects and organizations that were involved and get started.

Contributing to an open source project (code contibution)

Now you've found that project but you might be overwhelmed on how to get started with contributing to it. Here are some tips:

Visit the project's website and learn all it's about. Also find information about joining their community or public chat and make sure you join.
Go through the README file available in the root directory of the project's Git repository.
Download the latest release of the project and experience it first hand. Know the basic functionalities and how to navigate across the application.
Set Up your development environment by following the instructions on the README.md file and also read the CONTRIBUTING.md file for relevant info about contributing to the repo.
Clone the project and familiarize yourself with the code base and its documentation. The aim for this would be to help you build and run the project locally.
The issues are a great place to start once already familiar with the project and its code base. For newcomers, find issues labeled “newcomer” and “good first issue”.
Once you are familiar with working on issues or some of your PR have been successfully merged into the codebase, you can continue working on more issues with other tags like “help wanted”, “bug”, “feature”, etc.
If you are interested in working on an issue, comment on it and indicate your interest in working on it. You will be provided with more details and any resources requested and assigned if no other individual is assigned to it.
Fork the repository (if Github or Gitlab)
Create a branch with a name that matches the issue (or check the project's contributing guidelines on naming branches)
Make your changes and be sure it adheres to the coding standards/style.
Write a meaningful commit message which mentions the changes that have been introduced. Do not make several different unrelated changes and bundle them in a single commit.
Push changes to your remote fork.
Submit pull requests to the specified branch as per the contribution guidelines.
Make sure your pull requests are descriptive and tag the issue you are resolving to align issues with incoming fixes/changes. All PRs should match specific issues. PRs should be opened to match specific issues by tagging them. This is an important step to help align the issues with incoming fixes and changes.

Once you've submitted a PR, you wait for the review and depending on your changes, you might receive comments from the reviewer, they might request more changes or approve the PR. Address them accordingly and be able to accept a little constructive criticism. In addition, be polite in your communications and inquiries. Also make sure your questions are elaborate and you've done your research.

Making that first contribution might not be easy but as you get acquainted with the code base, it become a piece of cake and with time you will find yourself helping out new contributors find their way around. I believe it's important to contribute to project you enjoy using or those whose values and cause resonate with you so that you don't easily lose your motivation prompting you to stick around longer.

Sending out SMS messages via Twilio

Ida Delphine — Sun, 10 Mar 2024 22:12:07 +0000

In the previous post, we scrapped a job posting site and were able to get a couple of jobs. Rememeber, I mentioned in Part 1 we will scrap a webpage and sent jobs to a user via SMS. Talking about SMS you should definitely checkout this article.

Before we jump right into creating the SMS functionality, let's first of all store our scrapped data into a very simple SQLite database. I will be creating a new file called data.py. This is where the code handling our data storage will reside.
We will create a class which will handle all operations in relation to the data base from creating to adding to deleting data. For now we will implement a few methods to be sure the basic functionality at least works. When the class will be instantiated, a SQLite connection will be established and both the database and the table will be created if they don't exist. We will have 2 methods to save the data to the database and also retrieve data (for now). When storing our data, we will make sure the URL is the primary key to make sure duplicate data won't be saved. With time we will implement error handling and refine the class.

import sqlite3

class JobsDataBase:
    def __init__(self):
        self.conn = sqlite3.connect("jobs_data.sqlite")
        self.cur = self.conn.cursor()
        self.cur.execute('CREATE TABLE IF NOT EXISTS jobs (id VARCHAR, description VARCHAR, PRIMARY KEY (id))')
        self.conn.commit()

    def save(self, id, body):
        self.cur.execute(f'INSERT OR IGNORE INTO jobs (id, description) values ("{id}", "{body}")')
        self.conn.commit()
        print("done")

    def getjobs(self):
        self.conn = sqlite3.connect("jobs_data.sqlite")
        self.cur.execute('SELECT * FROM jobs')
        data = self.cur.fetchall()
        return data

Now let's create a function called save_data within scrapper.py. Don't forget to import data.py.

def save_data(jobs):
    jobs_data = data.JobsDataBase()
    for j in jobs:
        jobs_data.save(j[0], j[1])

The get_job_details function in scrapper.py has been modified to return a list of lists containing job URLs and descriptions.

def get_job_details(urls):
    job_details = []
    for url in urls:
        page = requests.get(url)
        soup = BeautifulSoup(page.content, "html.parser")

        job = soup.find("div", class_="job-description")
        job_details.append([url, job.find("p").text])
    return job_details

Now let's dive into implementing our SMS functionality. After savind data into our database, we want to send out an SMS to the user. Considering the fact that there won't be duplicte data stored in the database, there are zero chances of sending out an SMS more than once (unless there's a bug in the code)

We will be using Twilio to implement the SMS functionality. wilio is a cloud-based communications company that offers tools for making and receiving calls, sending messages, and more. Twilio's products include voice, video, messaging, authentication, and more.

Before we dive into the code, we will start by creating a Twilio account and download its python [helper library].(https://github.com/twilio/twilio-python). Run the following command.

pip3 install twilio

Make sure you setup your Twilio console and get your account SID and Auth token. Create the variables account_sid and auth_token in your code and assign them their values. Be sure to also generate your Twilio phonenumber which you will use to send SMS messages.

Now lets start by importing our Twilio client.

from twilio.rest import Client

Now we will create a send_sms function. In the fuction you can see we when conposing the message to be sent we limited the characters. That's because there's a character limit and for now we won't dwell on hacking that limitation as our main focus is sending out an SMS via Twilio.

def send_sms(url, job):
    client = Client(account_sid, auth_token)
    text = f"{job[:500]}\n\nVisit site: {url}"
    message = client.messages.create(
    from_='twilio-phone-number',
    to='receiver-phone-number',
    body=text
    )

We will be sending out an SMS after saving any job into the database. So we will add an extra line in our save_data function.

def save_data(jobs):
    jobs_data = data.JobsDataBase()
    for j in jobs:
        jobs_data.save(j[0], j[1])
        send_sms(j[0], j[1])

Running the save_data function will send out SMS messages depending on the number of jobs. In our next articles, we will refine the data base, send out SMS messages with all the details, etc

Web Scraping With Python (Part 2)

Ida Delphine — Sun, 03 Mar 2024 21:45:32 +0000

We shall be continuing where we left our Python scrapper. Our program was able to return all the job links of the homepage of fossjobs.net. However, we shouldn't end there. How about we build a tool that sends the user SMS messages of jobs they match with? That will mean we will have to access those individual links, access their info and make sure they match the user. For now we will be extracting info from the job link like the summary, job description, eligibility/qualifications/skills required and the link or steps to apply. This might be a little tricky but firstly we will start slowly.

Each of those job links have different formats of how their data is organized. You can clearly see that format of this rust developer role is different from this software engineer role. Considering the fact that there is no consistent format across all links, we will basically just pull everything from the links and pass the out put to a generative AI model to extract the relevant data we need.

This is how we previously left our code:

import requests
from bs4 import BeautifulSoup


URL = "https://www.fossjobs.net/"

# Gets html content of fossjobs.net
page = requests.get(URL)
soup = BeautifulSoup(page.content, "html.parser")

# extracts all html elements with an 'a' tag and 'neutral-link' class
job_elements = soup.find_all("a", class_="neutral-link", href=True)

for job_element in job_elements:
    job_link = job_element['href']
    print(job_link, end="\n"*2)

It's high time we "modularize" our code by placing different functionalities in different functions. The first function will accept a URL and return a list of links meanwhile the second function will accept this list of job urls, iterate through them and grab all the job details.

import requests
from bs4 import BeautifulSoup


def get_job_urls(url):
    # Gets html content of fossjobs.net
    page = requests.get(URL)
    soup = BeautifulSoup(page.content, "html.parser")

    # extracts all html elements with an 'a' tag and 'neutral-link' class
    job_elements = soup.find_all("h3")
    job_links = []

    for job_element in job_elements:
        job_link = job_element.find("a")["href"]
        job_links.append(job_link)

    return job_links

Now let's code the second function. We will call it get_job_details and it will accept a list of strings and print out the job details for now. Based on the html content there is a div with a class called job-description where in this div we have a paragraph tag.

def get_job_details(urls):
    job_details = []
    for url in urls:
        page = requests.get(url)
        soup = BeautifulSoup(page.content, "html.parser")

        job = soup.find("div", class_="job-description")
        print(job.find("p").text)
        job_details.append(job.find("p").text)
    return job_details

Next thing we will do is get to organize the data in a format which will enable us send jobs that are a good fit for our users and also to exclude sending jobs which are past the deadline.

Web Scraping With Python (Part 1)

Ida Delphine — Sun, 25 Feb 2024 21:04:08 +0000

Web Scraping is the act of extracting data from the web. In this tutorial, we will build a web scrapper that will extract information about various jobs. There are several python web scrapping libraries like requests, beautiful soup, etc

Let's start by creating our project directory in which we will have our virtual environment

python -m venv venv

Now activate your virtual environment

. venv/bin/activate

Now that your virtual environment is activated, you can conveniently install your library.

Now create your working directory and enter it

mkdir python-scrappper

cd python-scrapper

Create your requirements.txt file to keep track of all libraries/dependencies downloaded

touch requirements.txt

Download the requests library

python -m pip install requests

Create a file scrapper.py to carryout the scrapping from the fossjobs.net job board.
We will start by writing a simple program using to the request library to get all the html from the fossjobs website and write to a text file

import requests

URL = "https://www.fossjobs.net/"
page = requests.get(URL)

with open('readme.txt', 'w') as f:
    f.write(page.text)

Parsing with beautiful soup

Now that we have scrapped data from the fossjobs.net site, the output looks like a huge mess with just HTML tags all over the place. We are going to use beautiful soup to parse the data in the HTML. First, let's install beautiful soup

python -m pip install beautifulsoup4

We will add 2 extra lines in our code. The first one importing beautiful soup and the other one which creates a BeautifulSoup object that with our html content as its input.

import requests
from bs4 import BeautifulSoup


URL = "https://www.fossjobs.net/"
page = requests.get(URL)
soup = BeautifulSoup(page.content, "html.parser")

with open('readme.txt', 'w') as f:
    f.write(page.text)

The second argument of the BeautifulSoup object describes the type of parser which in this case will be an html parser.

When you visit a job board there are some key things you are looking for. The job title, it's description, and link to apply. These are what we want to currently extract from our html content. We can extract information by certain html elements like classes or ids. In our HTML content, we can see for every job post, there is an article tag with a class name post. In this scenario, we want to keep it simple by extracting just the links to all the job application pages. So we will make use of the a tag and the neutral-link class.

import requests
from bs4 import BeautifulSoup


URL = "https://www.fossjobs.net/"

# Gets html content of fossjobs.net
page = requests.get(URL)
soup = BeautifulSoup(page.content, "html.parser")

# extracts all html elements with an 'a' tag and 'neutral-link' class
job_elements = soup.find_all("a", class_="neutral-link", href=True)

for job_element in job_elements:
    job_link = job_element['href']
    print(job_link, end="\n"*2)

Our output should look somewhat like this:

https://tryquiet.org/jobs/

https://grnh.se/230c253d1us

https://apply.workable.com/digidem/j/96343A29BE/

https://okfn.org/en/jobs/senior-developer/

https://www.fsf.org/news/fsf-job-opportunity-outreach-and-communications-coordinator

https://wikimedia-deutschland.softgarden.io/job/40776229?l=de

https://wikimedia-deutschland.softgarden.io/job/40775956?l=de

Now add all dependencies in the requirements.txt file

pip freeze > requirements.txt

We have successfully scrapped the fossjobs.net website and gotten the links of all jobs in the home page. Next thing we will do is parse the content of these links and get other useful details.

How SMS messages are handled between 2G, 3G, 4G & 5G

Ida Delphine — Sun, 18 Feb 2024 20:52:14 +0000

Before the internet became a thing and mobile apps like WhatsApp, Signal, etc emerged for text communication on mobile devices, there was SMS. SMS stands for Short Messaging Service and that's pretty self explanatory as messages are limited to 160 characters in length.

With that said, you have probably sent out an SMS message before and even if you have never sent one, you've definitely received one. Have you ever wondered how it's possible to send SMS messages across different networks to different devices? That's thanks to the GSM (Global System for Mobile Communications) standards which ensure compatibility and interoperability between mobile devices and networks.

A little about cellular networks

Cellular networks allow mobile devices such as smartphones, tablets, and other wireless-enabled devices to communicate with each other and access the internet. They are made up of several components that work hand in glove. These include the mobile switching center (MSC), central office (CO), cell, base station, antenna, etc. As time passes by, cellular networks have evolved with improvements communication capabilities, data speeds, and the range of services offered to users. This evolution happened in "generations" reason for the "G" you see in 2G, 3G, etc

2G, 3G, 4G & 5G

Before we dive into the these generations, it is worth talking about 1G - the first generation which laid the foundation for mobile communication. It made use of analog signals for voice communication and it had several limitations which includes limited capacity to support a high volume of users, no encryption, and low call quality. The other generations came in to improve the quality of service of previous generations.

2G ( Early 1990s to early 2000s): The second generation significantly advanced the shortcomings of is predecessor and played a crucial role in the advancement of mobile communication. It played a huge role in improving voice quality and this was where GSM became dominant as it was time-division multiple access (TDMA)-based. IN TDMA, all the signals are given timeslots to pass through a single channel. What made 2G really special was phone conversations became encrypted, more users per frequency band, the introduction of SMS messages and the SIM (Subscriber Identity Module) card. International roaming was also introduced where users could use their mobile devices in other countries with 2G network.
3G (Early 2000s to around 2010): The third generation came about with higher data transfer rates, introduction of mobile internet access, video calling, and multimedia services.It made use of Wideband Code Division Multiple Access (WCDMA), CDMA2000, and others
4G/4.5G(LTE Advanced and LTE Advanced Pro) (Around 2010 onwards): The generation brought about significant increase in data speeds, lower latency, and improved capacity. 4G enabled widespread mobile broadband access, supporting applications like video streaming and online gaming. The primary standard was Long-Term Evolution (LTE) which is a wireless broadband standard for mobile communication and data transfer.
5G (2019 onwards): The fifth generation came in with extremely high data speeds, low latency, and support for a massive number of connected devices. It was designed to meet the diverse requirements of applications like augmented reality, virtual reality, IoT, and autonomous vehicles. Its primary standard is 5G NR (New Radio) which is designed to provide faster and more responsive mobile experiences than previous 4G standards.

Handling of SMS in 2G, 3G, 4G & 5G

1. 2G
The user starts by composing a message on their mobile device which is then forwarded to the Short Message Service Center (SMSC) - a centralized server that is responsible for storing, forwarding, and delivering SMS messages. It receives the incoming message and checks the address of its recipient to know where the message will be delivered to. The SMSC then checks if the recipient's device is available. If it is reachable, the SMSC forwards the message to their home location register (HLR), which is a database that contains subscriber information. If the recipient isn't available, the SMSC stores the message until the recipient become available (e.g turning on device). After the message has been routed to the receiver, the SMSC requests for a an acknowledgement to prove the message has indeed been delivered. If you notice when you send out an SMS you will find a single tick by the message blob which signifies its been sent. When the SMSC receives the acknowledgement of successful delivery it then notifies the user's device reason you realize the single tick changes to double ticks.

2. 3G
With 3G, it follows the same steps as 2G. What makes 3G better is the rate of data transfer is faster and there is the ability for users to send pictures, videos, audios through Multimedia Messaging Service (MMS)

3. 4G
4G follows same steps as 2 & 3G. What makes it better than its predecessors is all the capabilities of the previous generations are further enhanced and more efficient.

4. 5G
With 5G, once the message is composed and sent, it goes to the 5G core (5GC) network. Within the 5GC, ther is the Session Management Function (SMF) which is responsible for handling the signaling and routing of messages. It also contains the Access and Mobility Management Function (AMF) which is for handling SMS when devices move across different areas within the 5G network. Furthermore, there is the User Plane Function (UPF) which ensures the efficient and reliable transport of SMS data between the sender and recipient. The 5G network processes and delivers the message similar to that of previous generations but with significantly higher data rates.
5G networks are designed to provide low-latency communication. This can enhance the real-time delivery of SMS messages, making the service more responsive.

Managing Deadlock In Databases

Ida Delphine — Sun, 11 Feb 2024 15:58:31 +0000

It is common knowledge that databases are meant for storing data and it is the Database Management System (DBMS) that is in charge of controlling how data is stored, retrieved, and edited. You have probably written a program that accessed data from a database. What are the chances there wouldn't be any conflicts when trying to access this data?

What is deadlock?

Deadlock is a common concept when dealing with operating systems but not necessarily limited to operating systems. Imagine you are hungry and go to the kitchen to get food. Turns out your sibling is already by the pot and wants to serve themselves. But there is a problem, you are holding the only clean plate available but wouldn't be able to get food unless your sibling is done. Your sibling needs a plate in order to serve themselves food but you wouldn't give up your plate. Neither will your sibling leave the pot unless they get a plate. You need the pot to get food but your sibling is with the pot. Your sibling needs a plate to get food but you are with the plate. This is a "deadlock" kind of scenario. Deadlock is a situation where a computer process waits for a resource which is being assigned or used by another process.

In databases, a deadlock occurs when multiple transactions are waiting for the release of resources which leads a situation where neither can proceed. Deadlocks are not very frequent in databases but aren't inevitable. In the context of a database, a lock is a mechanism used to control access to a resource, such as a data row, table, or page. Locks are employed to ensure the consistency and integrity of the database by preventing multiple transactions from simultaneously modifying the same resource. When multiple transactions are involved, and they are waiting for each other to release locks, it can lead to a deadlock.

Here's a simple example to illustrate a deadlock scenario:

Transaction A holds a lock on Resource X and is waiting for Resource Y.
Transaction B holds a lock on Resource Y and is waiting for Resource X.

How to manage deadlocks in databases

Deadlock Prevention: Like they say "Prevention is better than cure". In order for this to happen, there should be an order in which transactions are being carried out. One transaction should wait for the other to release the lock before it can begin. There should be a hierarchy of acquiring locks ensuring these locks are requested in a consistent order. In addition, there should be a time limit for all transactions to acquire locks.This is ideal for small databases
Deadlock Detection: Here, resources are allocated in such a way that the deadlock never happens. The DBMS makes sure to assess the operations making sure there's no room for any deadlock else the transaction won't be executed. It involves periodically checking for deadlocks and this is perfect for very large databases.
Deadlock Resolution: Once a deadlock is identified, there are 2 things that should be done - abort & rollback and wait-die & wound-wait. With abort & rollback, one or more transactions that are involved in a deadlock are aborted in order to release their locks whereas in wait-die & wound-wait, transactions are prioritized based on their timestamps. Younger transactions requesting locks held by older transactions are aborted meanwhile older transactions with locks held by younger transactions are forced to wait.

TCP vs UDP

Ida Delphine — Sun, 04 Feb 2024 14:53:46 +0000

Before we jump right into what TCP and UDP is all about, we have to first understand the OSI (Opens Systems Interconnection) model. Do you ever think about what happens under the hood for data to transfered from one computer to another over the internet? The OSI model is used to visualize how this data is transmitted.

The OSI model comes in to abstract the way data is transmitted between different computers with different architectures. This OSI model is made up of 7 different layers; Application layer, Presentation layer, Session layer, Transport layer, Network layer, Data link layer, Physical layer. For data to be transmitted, it will pas through all these 7 layers starting from the application layer where there is human-computer interaction to the physical layer which transmits raw bits of data to a physical medium. Our key focal point will be the Transport Layer where we will be dissecting TCP and UDP.

What is TCP?

TCP stands for Transmission Control Protocol specifies how data should be broken down and sent until it reaches its destination. It works together with the IP (internet protocol). TCP determines how to break the data into packets and the IP is responsible for addressing and routing these data packets making sure it reaches the destination chronologically.
Imagine you want to access a webpage from the browser. Once the HTTP request is made, the TCP is responsible for transmitting the html file to your browser by splitting it into various packages. These packages are numbered and sent to your browser where they will assembled back to the html file for your viewing.
It is worth noting TCP is connection-oriented where before the data is split into packets and routed, a connection between the source and destination is established. This connection is known as a handshake.

What is UDP?

The User Datagram Protocol is another protocol used to transmit data across the internet. However, it is connectionless as there is no formal connection established between the sender and receiver before the data is transmitted. UDP sends data packets directly to the computer without any connection between the two.

TCP vs UDP

Comparatively, UDP is faster in terms of transmitting data than TCP whereas TCP is more reliable in the sense that the data is certainly going to reach its destination intact. TCP is slower because it takes time establishing the connection and if there's any data loss along the line a request will be made to obtain the missing data packet. They both have their strengths and weaknesses. UDP is commonly used in time-sensitive communications where packet loss is not a big deal and it's preferable than waiting e.g live streaming. TCP is ideal for scenarios where the data must be received intact without any data loss or alteration eg emails.

NB: It is worth noting the OSI model doesn't apply to the current internet and it's the TCP/IP model which is currently used. The TCP/IP model comes from merging some of the layers of the OSI model.