Nasir Hussain

Coding Conway's Game of Life - Cellular Automata - The Maths

Sun, 01 Jan 2023 19:25:32 +0500

In the past few days, I’ve been exploring mathematics and it’s various applications in Computational Theory and User Experience.

In this part one, I’ll be looking at Conway’s Game of Life from the mathematical perspective and it’s application on user experience.

Without any further ado, Let’s take a dive into it.

What is Cellular Automata?

Cellular Automata is a field of Automata Theory which is a part of Discrete Maths. Automata Theory has applications in Physics, Computational Theory, Biology, etc. Automata Theory consists of the study of various Computational Classes: Combinatorial Logic, Finite-State Machines, Pushdown Automation and Turing Machines.

Cellular Automata deals with Artificial life, which examines systems related to natural life, it’s processes, it’s evolution, through the usage of simulations with computer models.

Cellular Automata - How ??

Cellular Automata consists of a grid of cells, with discrete (finite states) e.g: On and Off. For each cell a set, a set of cells are called it’s neighborhood. It also consists of a set of discrete rules which are applied on each iteration. An initial state (t=0) is selected by defining the state of various cells. Upon each iteration (t+1), The set of rules are applied upon the whole grid and then the change is the state of the neighboring cells is then observed.

[Image for Grid of Cells, and state.]

Conway’s Game of Life

Conway’s Game of Life is invented by the famous Mathematician, “John Conway”. It is also often referred as “Life”. It is a zero-player game, meaning for it’s evolution to be defined by the initial state. It’s played on an infinite two-dimentional grid (However, For the sake of computing it, we’ll be using an nxn size for the grid).

Each cell has eight neighboring cells which are horizontally, vertically, or diagonally adjacent.

It consists of the following rules:

Any live cell with fewer than two live neighbours dies, as if by underpopulation.
Any live cell with two or three live neighbours lives on to the next generation.
Any live cell with more than three live neighbours dies, as if by overpopulation.
Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

Let’s look at the rules in action. (GIF for Rules).

Simple, Right ?

It consists of a grid of squares, simple rules and simple states for each cell.

Well, You’re in for a treat. Patterns:

There are various patterns (alot !!) that are discovered. However, we’ll be looking at some promiment ones below:

Still Life: It’s the most obvious pattern we can think of, It’s a state of cells, which are stabilized. Where neither cell is producing nor dying out.
Oscillators: It’s another obvious pattern where a set of cells keep oscilating between two states.

Simple rules, Simple patters, Huh ?

Let’s look at onther one:

Spaceships: A set of cells, which move together in one direction, leaving no traces behind. e.g: Glider (GIF below.)

Cool, Isn’t it. How about a Glider generator.

Glider Gun: It’s a pattern, which keeps oscilating (like an oscillator) and periodically emits spaceships like the Glider. e.g: Gosper’s Glider Gun creating gliders. (GIF).

Hmm, how about some pattern that leaves some traces behind, Introducing:

Puffer: It’s similar to a spaceship, however it leaves the traces behind. (Examples)

Why does it matter ?

Conway’s game of life is a perfect example to demonstrate how complex behaviour can emerge from simple rules iterated overtime along with providing a simple way to trace back each iteration.

It got me thinking about system design and how often times in order to develop a complex system, simplicity is often neglected. However, with simple rules we can create complex systems.

Thank You for Reading ! Stay tuned, I’ll be writing more about it and how to program it in Go Language.

Looking forward to your feedback on the post.

Exploring Google Cloud: Pub/Sub 101

Sun, 23 May 2021 19:25:32 +0500

In the past few days, I’ve been exploring services in Google Cloud Platform and I’ll be writing a series as “Exploring Google Cloud” to write about my learnings and take aways here.

In this series, I’ll be writing about Google Cloud Products which we can explore in our 300$ trial period.

We’ll be starting with one of the awesome products provided to us by Google Cloud called Pub/Sub.

What is Cloud Pub/Sub?

Pub/Sub is short for Publish/Subscribe Messaging and it is an asynchronous messaging service that decouples services that produce events from services that process events.

Availability: Global (In all GCP Regions around the world)

Let’s dig a little deeper into it.

It’s used in event-driven applications, where we can have applications publishing and subscribing to events that are available as messages.

As the name suggests, Pub/Sub Works in a Publisher / Subscriber model, Where a publisher publishes a message and the subscriber acknowledges that message.

How do we make sure that the Publisher publishes to the right place and the subscriber is listening to the right place? It’s where topics come in.

Core Components:

Let’s look at the Core constructs of what Pub/Sub is made of:

Topic: An intermediary channel that maintains a list of subscribers to relay messages to that are received from publishers
Message: Serialized messages sent to a topic by a publisher which has no knowledge of the subscribers
Publisher: An application which publishes a message to a topic.
Subscriber: An application that registers itself with the desired topic in order to receive the appropriate messages.

Pub/Sub Model:

As we now understand the Core components, Let’s look at how the Pub/Sub Model Works:

We start with creating a topic in Pub/Sub.
We then create a subscription for that topic, It plays the subscriber part of the Pub/Sub.
Now, we can publish messages in our Pub/Sub topic.
The messages are available in our Pub/Sub topic, Now the subscriber can consume those messages by acknowledging them.

Here’s a pictorial overview of it:

In the example above, We’ve got two seperate topics where messages will be published and a single consumer having two subscriptions providing the consumer the ability to consume messages from both the topics.

The same can be done for a publisher, a single publisher can publish messages to multiple topics too.

Some Benefits of Cloud Pub/Sub:

Loose Coupling: Publishers are unaware of the subscribers presence. It provides the ability for the system to function independently of each other.

Scalability: Pub/sub messaging can scale to volumes beyond the capability of a single traditional data center.

Let’s get hands-on with it.

Once, you’ve got your GCP account and gcloud CLI setup, We can make use of the gcloud CLI for this demo.

Demo:

Let’s assume the following scenario:

We’re running a Coffee Shop, Where customers have the ability to push messages to a topic with their order about cofee.

On each station our Baristas are subscribed to the topic and can pull one message at the time and ackowledge it to start brewing coffee for the customer.

Setup:

Creating the topic:

To create the topic in pub/sub, we’ll use glcoud CLI as following:

$ gcloud pubsub topics create coffee-shop

As we’ve got the topic created as coffee-shop, It’s time for the barista to join as a subscriber.

Creating a subscription for the topic:

$ gcloud pubsub subscriptions create --topic coffee-shop barista

In the above example, we’re creating a subscription as barista which subscribes to the topic created in the past step.

Yayyy !!, We’re done with our setup for Pub/Sub. Now we can integrate it with our applications as subscribers and publishers.

Publishing and Consuming Messages:

Let’s assume, we’ve got a customer, who needs an espresso with cinnamon, They can publish the following message in the coffee-shop topic as: {"coffee_type": "espresso", "cinnamon": "true"}

We can use the gcloud CLI to publish this message as:

$ gcloud pubsub topics publish coffee-shop --message '{"coffee_type": "espresso", "cinnamon": "true"}'

The gcloud CLI will publish the message on the coffee-shop topic.

And then we’ll have our barista free to take a coffee order, They can use their subscription to consume the messages, We’ll use Gcloud CLI for it too:

$ gcloud pubsub subscriptions pull barista --limit=1 --auto-ack

NOTE: We’re using the --limit flag to make sure, we only receive one message from the topic.

NOTE: For the --auto-ack flag to automatically acknowledge the message.

It’s available there to make sure the consumer receives the message successfully by acknowledging it’s receival.

We can also manually acknowledge the messages, Click here to learn more about it.

Summary:

Publish/subscribe messaging is when a publisher sends a message to a topic and the message is forwarded to a subscriber.
The concept of pub/sub is easy to understand but every coding and programming language handles it differently, making it a little more challenging to learn across all platforms.
On the edge, message delivery times can be two to four times faster by using a network backbone and multiple points of presence.

Thank You for Reading ! Stay tuned, I’ll be writing more about GCP Products and my experience with them in the near future.

Looking forward to your feedback on the post.

Running Pre-Built Binaries on Non-FHS *NIX Systems

Wed, 20 Jan 2021 00:28:56 +0500

Executing pre-built binaries on a new system can be a troublesome task to perform. Several exceptions can occur causing the execution to fail.

We’ll be looking at one of such that can occur on Linux systems quite often, which is: The file '<executable_file_name>' does not exist or could not be executed.

This exception occurs when it is unable to find one of the ELF libraries required to execute the binary.

In this blog post, we’ll be digging into it a little deeper to understand & find a solution:

How do binaries work in Linux?

Binaries are a set of instructions that are understood by the machine to perform a specific task.

Our day-to-day interaction with our terminal CLI (Command Line Interface) includes usage of programs like: bash, grep, ls, cd, etc., which are available typically in our: /bin (binary) directory. Example: We can use which (a binary itself) to find the location of the bash program:

$ which bash
/bin/bash

This provides us information on where the program is located on the disk.

Similar to standards being followed in our day-to-day life, binaries also follow a certain standard known as ELF or the Executable and Linkable Format.

ELF Standard for Binaries

ELF (Executable and Linkable Format) standard is used to let the Operating System know some information about how to execute the program. It’s something that we don’t interact with much on our daily basis, but can be quite helpful with debugging. ELF standard makes us extend our program to work efficiently at runtime.

Example: To run a C program, we don’t need the entire implementation of the C language itself in the codebase. Instead, we link a library (glibc) with our binary to let it know that it needs the C library to be executed.

Sounds pretty cool, right?

Let’s get back to the problem now.

As described earlier, the error: The file '<executable_file_name>' does not exist or could not be found occurs whenever there’s a dependency on a library that the binary is not able to find.

Let’s get to the debugging part

One thing that I love about UNIX-based systems is that we have the tools to debug almost everything. To get the list of dependencies or libraries required by a binary, we can use the ldd command. It prints the shared libraries required by the program on the command line. As an example. let’s see what a pre-compiled binary of NodeJS requires:

$ ldd ./node

		linux-vdso.so.1 (0x00007fff00bf9000)
		libdl.so.2 => /lib/libdl.so.2 (0x00007fc857f59000)
		libstdc++.so.6 => not found
		libm.so.6 => /lib/libm.so.6 (0x00007fc857e18000)
		libgcc_s.so.1 => /lib/libgcc_s.so.1 (0x00007fc857dfe000)
		libpthread.so.0 => /lib/libpthread.so.0 (0x00007fc857ddd000)
		libc.so.6 => /lib/libc.so.6 (0x00007fc857c1e000)
		/lib64/ld-linux-x86-64.so.2 => /lib64/ld-linux-x86-64.so.2 (0x00007fc857f60000)

Upon executing the program, it returns the following error:

$ ./node

Failed to execute process './node'. Reason:
The file './node' does not exist or could not be executed.

Do you know what the problem is? You guessed it right. It’s the libstdc++.so.6 library that is causing our binary to not execute.

Now that we know what’s causing the issue, let’s fix it.

For FHS (FileSystem Hirearchy Standard) Distros (Debian, Ubuntu, etc.)

As in FHS systems, we make some assumptions regarding our system which includes that all the libraries will be in /lib or relevant directories. It’s, then, easier to fix the issue.

In FHS standardized / compliant Linux distributions it can be easily solved by installing the relevant library’s package.

Example: For libstdc++.6:

On Debian/Ubuntu based distros: apt-get install libstdc++6

On CentOS/Fedora based distros: yum install libstdcxx

Once installed, it’ll be available in the /lib directory resulting in the ELF loader to find the library in /lib. You would then be able to execute node as following:

$ ./node
Welcome to Node.js v14.15.4.
Type ".help" for more information
>

Woohoo, it worked. Now let’s see how to fix it in non-FHS distributions, where we don’t have a global /lib directory. :D

For Non-FHS Distros (NixOS, etc):

To maintain the non-global state of a system in non-FHS distributions, we would not be modifying the state of our system. We will be patching the ELF binary to work correctly. Example in NixOS:

NixOS provides a tool: patchelf which is a small utility that provides us the ability to patch pre-compiled binaries without having to play with machine code (0s and 1s).

Let’s get started, we first need to find where out libstdc++.so.6 file lives in our /nix/store, which can be found via the following shell function:

function find_stdcplusplus_in_nix_store(){
		local _fileName="libstdc++.so.6";
		ls /nix/store | grep "gcc" | grep "lib" \
		| awk -v file="${_fileName}" '{printf("find /nix/store/%s -name %s\n");}' | sh \
		| awk -F'-' '{printf("%s %s\n", $3, $0);}' | sort | tail -n 1 | awk '{print $2;}'
}

It’ll return the full path of the library/the file name libstdc++.so.6. It’ll be something like: /nix/store/gcc-<hash>/lib/libstdc++.so.6.

We need to get to know the directory where our library lives. To find it, we can execute the following function:

...
function find_stdcplusplus_parent_dir_in_nix_store(){
		local _file="$(find_stdcplusplus_in_nix_store)";
		dirname "${_file}";
}

nix_store_location=$(find_stdcplusplus_dir_in_nix_store)

It returns the directory where the library exists i.e: /nix/store/gcc-<hash>/lib and stores it in a global variable as nix_store_location.

Now it’s time for the final operation in which we will be creating shell environment/s with patchelf using nix-shell to patch the ELF binary:

...
function patch_node_application(){
		nix-shell -p patchelf --run 'patchelf --set-rpath $nix_store_location bin/node'
		nix-shell -p patchelf --run 'patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" bin/node'
}

The first line within the function adds an rpath (runtime search path) to let our loader know that libstdc++ can be found in a specific directory in the Nix store.

The second line, with the ELF binary, the dynamic loader (ELF interpreter) is set to a static path which is generally not available under NixOS at: lib64/ld-linux-x86-64.so.2. We’re changing it to the dynamic loader available at $NIX_CC/nix-support/dynamic-linker.

After executing the function patch_node_application, it’ll patch the node binary and you’ll be able to execute it on NixOS.

To add the above script incorporated in your current build systems for NodeJS Projects, here’s a small addition to the shell script to only execute the function patch_node_application (Responsible for patching the node binary) if it’s running on NixOS:

...
if [ "cat /etc/os-release | grep 'nixos'" ]; then
	patch_node_application
fi

Now the shell script will only be executed if the system is running NixOS, and the node binary can now be executed too.

Thank you for reading! I’ll be writing more about ELF and Nix in the future.

Looking forward to your feedback on the post.

Thank You very much cateroxl for proofreading and editing the blog post.

Getting Started With Nix: Introduction

Wed, 16 Dec 2020 01:58:48 +0500

Recently, I installed NixOS on one of my machines to explore the Nix ecosystem, and to learn how it makes the process of creating deterministic and reproducible builds efficient and simpler.

This blog post series provides an introduction to the Nix package manager and how it works.

What is Nix?

Nix is a powerful, purely functional package manager designed to be a reliable and reproducible package-management system.

Nix is also the primary package manager for NixOS and can also be installed as an additional package manager on Linux and Mac OS X.

It also offers the following features:

Atomic Upgrades and Rollbacks;
Multiple versions of a package;
Multi-user package management, the ability to install certain packages for certain users only;
Effortless setup of build environments for a package, providing functional builds;
and many more.

How Nix Works

Packages in the Nix ecosystem are built from Nix expressions, which is a simple functional language that enables the packaging aspect for Nix (The package manager).

A Nix expression describes everything that goes into a package build, e.g: other packages (dependencies), sources, config files, environment variables, external patches, etc.

A Nix expression results in a derivation, which is a build of the expression, that takes some inputs and produces an output, outputs are almost always some /nix/store/some-hash-pkg-name path.

Below is an abstract diagram of how Nix expressions work:

As you can see, we’ve got an application written in C language and we’re creating a Nix expression for it, which includes some code patches, dependencies, configurations. The resultant derivation is then created in the Nix Store.

The essence of Nix in comparison to traditional Linux systems:

Nix emerges from the idea that FHS (Filesystem Hierarchy Standard) is fundamentally incompatible with reproducibility. Let me explain now:

With traditional Linux systems and package managers, you’ll find paths like /usr/bin/python or /lib/libm.so where packages are installed. But there are a lot of things that we don’t know about the file that’s there, for example:

What’s the version of the package the binary/library came from?
What are the libraries it uses?
What configure flags were enabled during the build?

These questions have a significant effect on the resulted build and can also change the behavior of the application.

Indeed, there are ways to get around this in FHS. We can link directly to /lib/libm.so or use /usr/bin/python3.7 in our shebang, but then there will still be a lot of unknowns.

Nix plays a pretty essential role in fixing it, by isolating the build itself resulting in reproducible build artifacts.

On Nix systems, the file paths look like this: /nix/store/<hash>-<name>-<version>.

If there’s something you’re unable to grasp…No worries! We’ll be exploring Nix further in the future with because this is only the first of the series.

Thank you for reading. In the next posts, we will be installing Nix and building some Nix expressions ourselves.

Thank you very much cateroxl and Hira Tariq for proofreading and providing your valuable feedback on the blog post.

Gotta Badge 'Em All: I Voted: Fedora 33 -- Participated in the Fedora 33 Elections!

Mon, 30 Nov 2020 03:04:54 +0500

This article is inspired by Justin W. Flory’s Gotta Badge `em All series about how to earn specific Fedora badges.

I Voted Fedora 33: What it’s about?

The I Voted Fedora 33 Badge is categorized as Community Badge and it’s defined in this Pagure Ticket

But What it’s all About ?

In short, it’s what it says in the Description : “You participated in Fedora 33 Elections”. It is awarded to people who vote in the Fedora Elections.

What are Fedora Elections ?

Fedora has several elected bodies that regularly conduct elections every release cycle. In addition, Fedora teams can request one-off elections from the Fedora Program Manager when trying to select new leadership or otherwise reach a decision through a formal voting process.

We currently have 3 Open Elections, that takes place every release whenever we have a free seat including:

FESCo (Engineering) [Fedora Engineering & Steering Committee]
Mindshare Committee. (Community) [I’m running for the Mindshare seat this year too]
Fedora Council.

How the Election Process works ?

Fedora Implements a Range voting system, which works on the principle of allowing voters to rate as many candidates as they want on scale from 1 to 4.

This method is designed to give voters the option of splitting their vote and showing their level of preference of a subset of candidates over another.

Once voting ends, votes are tallied using the summing method (addition of all votes) to generate a final score for a candidate.

How do I earn “I Voted: Fedora 33” ?

Earning I Voted: Fedora 33 is pretty easy & can be only obtained till Thursday, December 3rd 2020, 23:59:59 UTC, The process is pretty simple:

To vote for Different elections, there are different eligiblity crieteria:
- To vote for the Fedora Council you must have cla_done in FAS.
- To vote for FESCo you must have cla_done + one other “non-cla” group in FAS.
- To vote for Mindshare you must have a cla_done in FAS.
- In Case, You’re not eligible, You can create a ticket here
Once you’re eligible, You can head over to the Fedora Elections App here
Login with your FAS ID.
One you’re logged in, A page would appear with a list of all the Open Election
Then you can click on Vote Now in the Open election you would like to vote on.
The Voting page would appear with all the Candidates for the specific election along with their Interviews to get to know them better
Once you select the votes in the Range counter and when you would select Preview your Vote -> Submit Your Vote, A unique link would be generated to claim the badge.
On clicking the link, it would redirect you to a Fedora Badges link where you can sign in and it would automatically award you the badge.

Best of Luck with Claiming the Badge.

Gotta Badge 'Em All: Fedora Social Panda

Fri, 01 May 2020 02:56:46 +0500

This article is originally inspired by Justin W. Flory’s Gotta Badge `em All series about how to earn specific Fedora badges.

How It all Started is, As COVID-19 is getting pretty real and resulting in people performing social distancing, shelter-in-place & Lockdowns resulting in most of us feeling pretty isolated so out Fedora Project Leader Matthew Miller & Fedora Project Contributor Neal Gompa had the idea to have a Fedora Social Hour where folks could Chat & get a little e-human contact and conversation.

Now, let’s focus on the badge now, As we have activities in Fedora, We have Badges, the Fedora Social Panda badge is categorized as “Event Badge” and it’s crieteria is defined in this Pagure ticket

In short, The Fedora Social Panda Badge is awarded to folks we participate in a Fedora Social Hour with the Community.

In order to earn this badge, you would have to join a weekly fedora social hour.

How do I know when it’s happening?

To know when a Fedora Social Hour will be organized, Keep an eye on the Fedora Community Blog, As that’s where most of the announcements are made for the Community.

Another preffered way is to keep an eye is by joining the Fedora Social Hour on Riot.im, As this is where we have our Social Hours nowadays, as it has Jitsi & Etherpad widgets that we’ve implemented.

If you would like to stick with the Freenode IRC Channel, it’s #fedora-social-hour on Freenode IRC that is bridged with the Matrix Room.

Once, You attend a Fedora Social Hour, you can share your FAS ID for the organizers to award that badge to you.

Looking forward to see you all in the next Fedora Social Hour, I’m nasirhm there. :D

Gotta Badge 'Em All: Fedora & CentOS Social @ Summit 2020

Wed, 29 Apr 2020 06:19:13 +0500

This article is inspired by Justin W. Flory’s Gotta Badge `em All series about how to earn specific Fedora badges.

The Fedora & CentOS Social @ Summit 2020 badge is categorized as a “Event Badge” and it’s defined in this Pagure ticket But what it’s all about?

In short, the Fedora & CentOS Social @ Summit 2020 badge is awarded to people who attended the Red Hat Virtual Summit 2020 & Participated in The Fedora Chatroom on April 28-29. There are some really awesome Fedora & CentOS folks having some really insightful & fun discussions there. This badge is a fun way to represent your participation in the Redhat Virtual Summit 2020 on the Fedora & CentOS Chatroom.

Earning Fedora & CentOS Social @ Summit 2020 is pretty easy & can only be attained on April 28-29 2020. The steps are pretty Simple:

Sign Up/Sign In for the Redhat Virtual Summit 2020
After logging in, Goto, Explore -> Community Central -> Fedora/CentOS
Communicate your thoughts/ideas in the live chat.
Dont’t forget to share your FAS id in the live chat, For the badge to be awarded. :D

In Case, you don’t have a FAS Id, here’s a link to sign up.

Note : This Badge can only be awarded on April 28-29 2020, As it’s about Redhat Virtual Summit, One Day’s left (When I’m writing this article).

Looking forward to see you all in the Fedora & CentOS Social at Redhat Summit.

Getting Started with Fedora QA - Part 1

Tue, 07 Apr 2020 17:29:03 +0500

What is SQA (Quality Assurance) ?

According to Wikipedia : Software quality assurance (SQA) is a means of monitoring the software engineering processes and methods used to ensure proper quality. SQA encompasses the entire software development process, including requirements definition, software design, coding, code reviews, source code control, software configuration management, testing, release management and product integration. It is organized into goals, commitments, abilities, activities, measurements and verification.

By simplifying, Software Quality Assurance is a way to ensure that the Code/Software that a developer has written has been tested across different mediums and produces the expected results.

Why Quality Assurance is an essential component for Fedora Project

Fedora is an Open Source Linux distribution Operating System which releases once in every six months and as a result the environment becomes very fast paced and that could make things break among general users of the distro, to prevent that to happening to users & to make sure everything works as expected, Quality Assurance is a must in Fedora Project. In Fedora, we have to encompass the user experience as there are thousands and thousands of people who expect a more stable & feature enriched OS that gets better with each release.

Fedora Release Cycle

Before we jump into practical tools, let’s have a quick introduction to how the process works

The above diagram displays a clear demonstration of how Fedora creates it’s release

It includes these branches:

Rawhide serves as the upstream for the release branch, it’s a bleeding edge, non freezing branch where contributors consitently push their packages, after a time slice we branch out different necessary packages and the Rawhide keeps on growing.

Branched Release is the version which gets branched out from the ongoing Rawhide & starts to get tested & refines for the release. As we reach this point, the QA team gets hands on with it :)

Prerequisites

FAS ID : https://admin.fedoraproject.org/accounts/

A FAS (Fedora Account System) account is essential for you to get login access to all subprojects in Fedora with the same user ID and passwords.

Bugzilla : https://bugzilla.redhat.com/

Bugzilla serves as the bug tracking system for Fedora Project, with Bugzilla you can create & verify bugs along with fixing some! :)

To register on Bugzilla, We recommend using your @fedoraproject.org email Alias, because in different places for QA you would require it.

NOTE : If you don’t have a @fedoraproject.org email Alias, We have a good news for you, you can reach out to us on Fedora Join and we can provide you a temporary membership, which would give you the ability to attain your email Alias.

After setting up your accounts, you can reach out to the QA Team on IRC, As it’s the place where most of the QA team is available, The channel for Fedora QA is: #fedora-qa and for Matrix users, It’s: #freenode_#fedora-qa:matrix.org

Another alternative to IRC, is mailing lists where you can have discussions with Fedora QA team, in case if you need any clarification or being faced by issues. Mailing list requires you to subscribe to it before you can post/ask/talk. The fedora QA mailing list resides here : test

To subscribe to the mailing list you would need a FAS ID too.

Best of luck for starting QA with Fedora Project.

The next post would be more about getting involved and hands on with QA.

Thank You for reading, if you have any doubts or questions feel free to reach out to me here : Contact

Contact & Social Network accounts

Mon, 06 Apr 2020 03:55:11 +0500

IRC Nick:
- irc.freenode.net: nasirhm
- Channels where you can find me: #fedora-join, #fedora-commops, #fedora-diversity …
Email: [spam protection, base64 encoded]
- bmFzaXJodXNzYWlubTE0@gmail.com (personal)
Time Zone: UTC + 05:00 (PKT)
FAS Account: nasirhm
Social Networks:
- Twitter: _nasirhm_
- Linkedin: nasirhm
- Github: nasirhm
- Pagure: nasirhm
- Facebook: dev.nasir.h

Nasir is

Mon, 06 Apr 2020 03:38:58 +0500

He/His/Him
FOSS Enthusiast & Evangelist
On the Path to become a Gopher & Pythonista

Work

Advocate @ Fedora Project
Sr. DevOps Intern @ Nisum

Contact Page

Introduction to FOSS and Fedora Project

Sat, 15 Feb 2020 01:29:42 +0500

Introduction to Free and Open Source Software and Fedora Project

Originally presented at Fedora 31 Release Party Karachi on 15th Feb 2020 in Karachi, Pakistan

Key points

What is FOSS, Free and Open Source Software
Perks of contributing to a FOSS
What is Fedora Project
- Four Foundations
Where to contribute
How to start contributing

Slides

Google Slides

Nasir Hussain

Coding Conway's Game of Life - Cellular Automata - The Maths

What is Cellular Automata?

Cellular Automata - How ??

Conway’s Game of Life

Well, You’re in for a treat. Patterns:

Why does it matter ?

Exploring Google Cloud: Pub/Sub 101

What is Cloud Pub/Sub?

Core Components:

Pub/Sub Model:

Some Benefits of Cloud Pub/Sub:

Let’s get hands-on with it.

Demo:

Setup:

Creating the topic:

Creating a subscription for the topic:

Publishing and Consuming Messages:

Summary:

Running Pre-Built Binaries on Non-FHS *NIX Systems

How do binaries work in Linux?

ELF Standard for Binaries

Let’s get to the debugging part

For FHS (FileSystem Hirearchy Standard) Distros (Debian, Ubuntu, etc.)

For Non-FHS Distros (NixOS, etc):

Getting Started With Nix: Introduction

What is Nix?

How Nix Works

The essence of Nix in comparison to traditional Linux systems:

Gotta Badge 'Em All: I Voted: Fedora 33 -- Participated in the Fedora 33 Elections!

I Voted Fedora 33: What it’s about?

But What it’s all About ?

What are Fedora Elections ?

How the Election Process works ?

How do I earn “I Voted: Fedora 33” ?

Gotta Badge 'Em All: Fedora Social Panda

Fedora Social Panda: What’s it about?

How do I earn “Fedora Social Panda”

How do I know when it’s happening?

Gotta Badge 'Em All: Fedora & CentOS Social @ Summit 2020

Fedora & CentOS Social @ Summit 2020: What’s it about?

How Do i earn “Fedora & CentOS Social @ Summit 2020” ?

Getting Started with Fedora QA - Part 1

What is SQA (Quality Assurance) ?

Why Quality Assurance is an essential component for Fedora Project

Fedora Release Cycle

Prerequisites

FAS ID : https://admin.fedoraproject.org/accounts/

Bugzilla : https://bugzilla.redhat.com/

Contact & Social Network accounts

Nasir is

Work

Contact & Social Network Accounts

Introduction to FOSS and Fedora Project

Introduction to Free and Open Source Software and Fedora Project

Key points

Slides