<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Nerfed on Medium]]></title>
        <description><![CDATA[Stories by Nerfed on Medium]]></description>
        <link>https://medium.com/@stevenyasimi01?source=rss-c89f803a7cdf------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*P8MsWLXxDPvL3Dib</url>
            <title>Stories by Nerfed on Medium</title>
            <link>https://medium.com/@stevenyasimi01?source=rss-c89f803a7cdf------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 14:10:03 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@stevenyasimi01/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[The Network File System]]></title>
            <link>https://medium.com/@stevenyasimi01/the-network-file-system-176ac27b2fdb?source=rss-c89f803a7cdf------2</link>
            <guid isPermaLink="false">https://medium.com/p/176ac27b2fdb</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[filesystem]]></category>
            <category><![CDATA[operating-systems]]></category>
            <dc:creator><![CDATA[Nerfed]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 09:41:48 GMT</pubDate>
            <atom:updated>2026-11-18T09:41:48.227Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*FO6x0GoOYllG8oEb" /><figcaption>Photo by <a href="https://unsplash.com/@qwitka?utm_source=medium&amp;utm_medium=referral">Maksym Kaharlytskyi</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Network file system is an internet standard protocol that allows operating systems/computers on the internet or local network to use a remote computer’s file system as it’s own; this is either through TCP or UDP, depending on NFS version. NFS supports native linux file permissions and file system attributes.</p><p>NFS has both a server and a client. Servers export directories while clients mount these diirectories as local.</p><p>Mounting can be manual, persistent or automatic.</p><p>Manual mounting occurs when a client mounts the exported directory using the mount command <em>This mount does not persist after a reboot</em>. To mount an export persistently, we use the etc/fstab file and add a new entry, to mount the exports automatically, we make use of automount&#39;s autofs service.</p><h4>Finding exported directories on a host</h4><p>To find out which directories a server exports/exposes. you use the showmount -e servername.</p><h4>Mounting exported directories</h4><p>To mount exposed directories, we use the mount option with the -t flag, the flag is optional as the command will autodetect if it&#39;s a NFS mount because of the <em>server:/export mountpoint</em> . After mounting, you can browse the file system normally.</p><h4>Persistently mounting an export</h4><p>To peristently mount an export, you’ll need to add an entry in the /etc/fstab file. below is an example</p><pre>server:/exported_dir /mnt/exports nfs rw,sync 0 0</pre><h4>Unmounting an export</h4><p>To unmount, you simply use the umount *mountpoint* command. To unmount a permanent mount, you first unmount the mountpoint, then delete the entry from the /etc/fstab file.</p><h4>Automatic Mounting</h4><p>Automatic mounting happens throught the autofs service. Mounting NFS exports comes with advantages like; it does not require the intervention of a root user, it automatically unmounts the export when not in use after timeout, saving resources and avoiding file system corruption. Automounting also mount an export on-demand.</p><p>There are two ways to achieve automounting;</p><ul><li>Direct mounts</li><li>Indirect mounts</li></ul><p>Both are configured using special files known as the Master file and the Map file. The master file is used to map a mount point to a map file. This file can be found in the /etc/ dir as auto.master, though to confugure your own, it is recommended to create your custom drop in file in the /etc/auto.master.d/ directory. Master files can have any name but must end in the .autofs extension</p><p>A map file has the following name format /etc/auto.*name*, where name represents the content of the file. The automounter, using the map file creates directories if they do not exist before it starts, if the directory already exists, the automounter does not remove or recreate them. If a timeout is specified, the directory is automatically unmounted.</p><h4>Direct mounts</h4><p>In direct mounts, the mount point is fixed, the file system mounts is unchanging, and a direct mount exists as a permanent directory. To create a direct mount file, you use the following format on the master file. A direct mount point exists exists as a permanent directory.</p><pre>*Mountpoint* *map-file*<br>/-        /etc/auto.direct</pre><p>A direct map file configures the properties of individual on demand mount points. It specifies an absolute path to the mount point. Below is an example of a mapfile configuration.</p><pre>*mountpoint* *options*  *source_export*<br>/mnt/docs      -rw,sync  host:/share/docs</pre><p>The mount point options start with (-) and are comma separated with no spaces</p><h4>Indirect mounts</h4><p>In indirect mounts, a mount point location is unknown until the mount demand occurs. Although indirect mount point appear exists, the autofs service creates them when the mount demand occurs, and deletes them when the demand ended and the file system is unmounted.</p><p>To create an indirect mount, the master file will be as follows.</p><pre>*mount point*       *mapfile*<br>/shares             /etc/auto.indirect</pre><p>In this setting, the /shares directory will be the base mount point for the indirect mount. the /etc/auto.indirect mapfile contains the mount details. The map file will have the following details</p><pre>*mount point*       *mount-options*     *source*<br>work                -rw,sync            hosta:/shares/work</pre><p>Wildcards in MapFiles</p><p>When the NFS server exports multiple subdirectories, the automounter can be configured to access the subdirectories with a single mapping entry. For that, in the map file, on the mount option you specify the (*) wildcard character and specify an ampersand(&amp;) in the source location. The map file will look like this</p><pre>*mountpoint*    *options*   *source*<br>*               -rw,sync    hosta:/shares/&amp;</pre><p>So if a user tries to access /shares/work the wildcard would automatically resolve to /shares/work</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=176ac27b2fdb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Journald]]></title>
            <link>https://medium.com/@stevenyasimi01/journald-ca0d17315dc3?source=rss-c89f803a7cdf------2</link>
            <guid isPermaLink="false">https://medium.com/p/ca0d17315dc3</guid>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[journald]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[Nerfed]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 06:42:46 GMT</pubDate>
            <atom:updated>2026-11-17T06:42:46.475Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8S73EBRHhyEAZiL8" /><figcaption>Photo by <a href="https://unsplash.com/@andrew741?utm_source=medium&amp;utm_medium=referral">Andrew</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>A walkthrough on how the linux system records and keeps logs. The linux Diary</p><h4>Introduction</h4><p>To understand system logging, we’ll need to understand the rsyslog service. The rsyslog service is responsible for collecting, sorting and writing the syslogs messages to log files located in the /var/log directory. In addition to the syslog messages, the /var/log directory contain logs from other services.</p><h4>RsysloG</h4><p>Rsyslog uses the syslog protocol to implement syslogging. Applications and developers can configure rsyslog with rules to determine how to handlethe logs. These files are drop-in located in the /etc/rsyslog.d/ directory, these files should also have the .conf extension.</p><p>These rules are made up of a filter, followed by an action. Filters select a subset of the syslog messages, these filters can be priority/facility based, it is possible to use a wildcard (*) to match all the possible values. <strong>Actions</strong> indicate how to handle these messages, actions can also include a path to save the messages and an action can be more than one for each rule.</p><p>Example: to save any message from the authpriv facility in the /var/log/secure file, such a rule would be</p><pre>authpriv.* /var/log/secure</pre><p>It is possible to specify a priority for a rule; all messages of that facility of that priority will be saved to the action. Example: To save all messages from the authpriv facility with the warning priority to /var/log/secure, the rule will be</p><pre>authpriv.warning /var/log/secure</pre><p>Key</p><ul><li><strong>Facility</strong> : THe source or component that geberated a system message; origin of a message</li></ul><h4>Log rotation</h4><p>Log rotation is needed to prevent the log files from taking up alot of disk space in a system. The system does this by running the logrotate command, this is periodically triggered by a system unit, <a href="https://www.digitalocean.com/community/tutorials/understanding-systemd-units-and-unit-files">read about system units here</a>.</p><p>After approximately 4 weeks, the earliest log files are deleted to reclaim disk space, log files are saved according to this format /var/log/messages-YYYMMDD. After the log file is rotated, a new log file is created and the log files&#39; associated system is notified.</p><p>Logrotate command rotates logs according to configurations or when a log file reaches a certain size.</p><h4>Sending logs manually</h4><p>To send logs manually, the logger command is used, it sends alerts to the rsyslog service. It sends the user type and priority of the message.</p><h4>Finding Events in the system-journal</h4><p>The system uses the systemd-journald service to log events, it logs events in an indexed binary file known as a journal. It also contains metadata about the log event.</p><p>To retrieve messages from the journal, we use the journalctl command. Running this command as the root user, it shows all the messages as compared to a normal user whose output is limited. The output is also color-coded; notice and warning priority messages in bold, while error priority or higher are in red.</p><h4>Journalctl options</h4><p>Journalctl supports varioius options depending on what you want to see.</p><ul><li>To see n number of lines, you can run</li></ul><pre>journalctl -n 5<br> <br>    Nov 16 11:01:01 kofianyekundu CROND[10330]: (root) CMD (run-parts /etc/cron.hourly)<br>    Nov 16 11:01:01 kofianyekundu run-parts[10333]: (/etc/cron.hourly) starting 0anacron<br>    Nov 16 11:01:01 kofianyekundu run-parts[10339]: (/etc/cron.hourly) finished 0anacron<br>    Nov 16 11:01:01 kofianyekundu CROND[10329]: (root) CMDEND (run-parts /etc/cron.hourly)</pre><ul><li>Journalctl also supports following, like the tail command. To follow output, continiously, you run the command with the -f option.</li></ul><pre>journalctl -f <br>    Nov 16 10:46:01 kofianyekundu systemd[1]: Starting fwupd-refresh.service - Refresh fwupd metadata and update motd...<br>    Nov 16 10:46:01 kofianyekundu systemd[1]: fwupd-refresh.service: Deactivated successfully.<br>    Nov 16 10:46:01 kofianyekundu systemd[1]: Finished fwupd-refresh.service - Refresh fwupd metadata and update motd.<br>    Nov 16 10:54:56 kofianyekundu wpa_supplicant[1494]: wlo1: CTRL-EVENT-BEACON-LOSS<br>    Nov 16 10:57:21 kofianyekundu wpa_supplicant[1494]: wlo1: RSN: Group rekeying completed with 48:bf:74:3c:28:17 [GTK=CCMP]<br>    Nov 16 11:01:01 kofianyekundu CROND[10330]: (root) CMD (run-parts /etc/cron.hourly)<br>    Nov 16 11:01:01 kofianyekundu run-parts[10333]: (/etc/cron.hourly) starting 0anacron<br>    Nov 16 11:01:01 kofianyekundu run-parts[10339]: (/etc/cron.hourly) finished 0anacron<br>    Nov 16 11:01:01 kofianyekundu CROND[10329]: (root) CMDEND (run-parts /etc/cron.hourly)</pre><ul><li>To filter output by priority, you run the journalctl command with the -p option and the priority(can be name or number). The journal supports the following levels</li><li>debug</li><li>info</li><li>notice</li><li>warning</li><li>err</li><li>crit</li><li>alert</li><li>emerg</li></ul><pre>$ journalctl -p err<br>Nov 16 12:04:07 kofianyekundu kernel: x86/cpu: SGX disabled or unsupported by BIOS.<br>Nov 16 12:04:07 kofianyekundu kernel: ACPI BIOS Error (bug): Could not resolve symbol [\_SB.PCI0.DGPV], AE_NOT_FOUND (20240827/psargs-332)<br>Nov 16 12:04:07 kofianyekundu kernel: ACPI Error: Aborting method \_SB.PCI0.RP05.PCRP._ON due to previous error (AE_NOT_FOUND) (20240827/psparse-529)<br>Nov 16 12:04:08 kofianyekundu kernel: Warning: Unmaintained driver is detected: cnic<br>Nov 16 12:04:08 kofianyekundu kernel: Warning: Unmaintained driver is detected: cnic_init<br>Nov 16 12:04:08 kofianyekundu kernel: Warning: Unmaintained driver is detected: bnx2i<br>Nov 16 12:04:08 kofianyekundu kernel: Warning: Unmaintained driver is detected: bnx2i_mod_init<br>Nov 16 09:04:13 kofianyekundu bluetoothd[1293]: Failed to set mode: Failed (0x03)<br>Nov 16 09:05:15 kofianyekundu gdm-password][3175]: gkr-pam: unable to locate daemon control file</pre><p><em>alerts of type err will be red in color</em></p><ul><li>To filter messages from a particular unit, you can use the -u option</li></ul><pre>journalctl -u sshd.service<br> <br>Nov 16 09:04:14 kofianyekundu systemd[1]: Starting sshd.service - OpenSSH server daemon...<br>Nov 16 09:04:14 kofianyekundu sshd[1510]: Server listening on 0.0.0.0 port 22.<br>Nov 16 09:04:14 kofianyekundu sshd[1510]: Server listening on :: port 22.<br>Nov 16 09:04:14 kofianyekundu systemd[1]: Started sshd.service - OpenSSH server daemon.</pre><ul><li>Journalctl also supports filterig output by certain time range, by using the --since and --until options. The time ranges can take time arguments such as today, yesterday and tomorrow, these are considered valid. But if you want to specify time, it takes the <em>&quot;YYYY-MM-DD hh:mm:ss&quot;</em> format. the space is preserved to separate the date and time formats, ideally you can supply either the date or time alone.</li></ul><p>Example: To view today’s logs, you can simply run</p><pre>$ journalctl --since today<br> <br>Nov 16 10:01:02 kofianyekundu anacron[8028]: Anacron started on 2026-11-16<br>Nov 16 10:01:02 kofianyekundu anacron[8028]: Will run job `cron.daily&#39; in 24 min.<br>Nov 16 10:01:02 kofianyekundu anacron[8028]: Jobs will be executed sequentially<br>Nov 16 10:01:02 kofianyekundu run-parts[8030]: (/etc/cron.hourly) finished 0anacron<br>Nov 16 10:01:02 kofianyekundu CROND[8014]: (root) CMDEND (run-parts /etc/cron.hourly)<br>Nov 16 10:01:23 kofianyekundu systemd[1]: Starting plocate-updatedb.service - Update the plocate database...<br>Nov 16 10:01:25 kofianyekundu systemd[1]: plocate-updatedb.service: Deactivated successfully.<br>Nov 16 10:01:25 kofianyekundu systemd[1]: Finished plocate-updatedb.service - Update the plocate database.<br>Nov 16 10:01:25 kofianyekundu systemd[1]: plocate-updatedb.service: Consumed 1.356s CPU time, 209.4M memory peak.<br>Nov 16 10:02:13 kofianyekundu org.mozilla.firefox.desktop[4507]: Safe Browsing server returned a 400 during update:request url = https://safebrowsin&gt;<br>Nov 16 10:03:41 kofianyekundu cupsd[1507]: REQUEST localhost - - &quot;POST / HTTP/1.1&quot; 200 183 Renew-Subscription successful-ok<br>Nov 16 10:08:03 kofianyekundu chronyd[1300]: Selected source 160.119.216.206 (2.rhel.pool.ntp.org)<br>Nov 16 10:22:54 kofianyekundu chronyd[1300]: Selected source 162.159.200.1 (2.rhel.pool.ntp.org)<br>Nov 16 10:25:02 kofianyekundu anacron[8028]: Job `cron.daily&#39; started<br>Nov 16 10:25:02 kofianyekundu run-parts[8747]: (/etc/cron.daily) starting brave-browser<br>Nov 16 10:25:02 kofianyekundu run-parts[8751]: (/etc/cron.daily) finished brave-browser<br>Nov 16 10:25:02 kofianyekundu run-parts[8753]: (/etc/cron.daily) starting google-chrome<br>Nov 16 10:25:02 kofianyekundu run-parts[8772]: (/etc/cron.daily) finished google-chrome<br>Nov 16 10:25:02 kofianyekundu anacron[8028]: Job `cron.daily&#39; terminated<br>Nov 16 10:25:02 kofianyekundu anacron[8028]: Normal exit (1 job run)</pre><p>to view all journals since 2026–11–12 to 2026–11–14</p><pre>$ journalctl --since 2026-11-12 --until 2026-11-14<br> <br>*..too long, omitted*</pre><p>To check all entires in the past hr</p><pre>$ journalctl --since &quot;-1 hour&quot;<br> <br>*....omitted...too long*</pre><p>Other filters include</p><pre>**_COMM** : command name : $ journalctl _COMM=dnf <br>**_EXE** : path to executable : $ journalctl _EXE=/usr/bin/dnf<br>**_PID** : process ID : $ journalctl _PID=2216<br>**_UID** : user ID : $ journalctl _UID=0<br>**_SYSTEMD_UNIT** : systemd unit that started the process : $ journalctl _SYSTEMD_UNIT=sshd.service</pre><h4>Configuring a persistent system journal</h4><p>By default, the journal files are saved in the /run/log/journal directory which is volatile; clears after a system reboot. To configire a persistent one, you can create the /var/log/journal directory. If this is done during run time, then it is wise to run $ journalctl --flush operation to copy all log files in the volatile dir to the persistent one</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ca0d17315dc3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Linux storage management with LVM]]></title>
            <link>https://medium.com/@stevenyasimi01/linux-storage-management-with-lvm-d54e0357ea84?source=rss-c89f803a7cdf------2</link>
            <guid isPermaLink="false">https://medium.com/p/d54e0357ea84</guid>
            <category><![CDATA[logical-volume-management]]></category>
            <category><![CDATA[storage]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[Nerfed]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 06:41:11 GMT</pubDate>
            <atom:updated>2026-11-17T06:41:11.790Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ao-nUrbERdVx_qz7" /><figcaption>Photo by <a href="https://unsplash.com/@wwarby?utm_source=medium&amp;utm_medium=referral">William Warby</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Linux has a cool technology known as LVM. This technology is built into the linux kernel. Logical volume management is a technology that helps with the management of storage in linux systems, LVM allows you to “grow” and “shrink” your storage space using commands, this can be done while a system is operational and without unmounting file systems. It creates an abstraction layer on the physical storage devices like your harddisks(block devices).</p><p>LVM is made up several components that work together; These are</p><ul><li>Physical devices Physcal devices are the actual harddisk that store the data.</li><li>Physical Volumes Physical volumes are the initialized physical devices. Initialized because physical devices are converted to physical volumes before LVM can make use of these. Physical volumes are segmented to physical Extents which are small chunks of data that act as storage blocks.</li><li>Volume groups A volume group is a storage pool that is made up of one or more physical physical volumes, the VGs have fixed physical extent size during creation but it possible to modify this value during vg creation by using the -s SIZE flag. A PV is allocated to a single VG.</li><li>Logical volumes Logical volumes are the smallest unit,logical volumes are provided as storage devices for applications, users and OSs. A logical volume is created from Volume group. Lv is made up of several Logical extents which are mapped to Physical extents, it possible to map one logical extent to 2 physical extents(mirroring).</li></ul><h4>To create:</h4><p>Physical volumes</p><p>This is done by identifying which devices will be used by the LVM. After that you need to initialize them as physical volumes bu running the command</p><pre>$ pvcreate /dev/sda /dev/sdb</pre><p>This will initialize the devices as physical volumes and have them ready for LVM.</p><p>Volume groups</p><p>Volume groups are storage pools, in the sence that, you can allocate one or more physical volumes to a single volume group. To create a volume group, you will need to assign physical volumes to a named volume group. You use the command vgcreate VOL_GROUP_NAME DEVICE-1 DEVICE-2.</p><pre>$ vgcreate my_volgroup /dev/sda /dev/sdb<br> Volume group &quot;my_volgroup&quot; successfully created</pre><p>To specify a physical extent size, you pass it the -s flag with the size you prefer.</p><pre>$ vgcreate -s 32 my_volgroup2 /dev/sda /dev/sdb<br> Volume group &quot;my_volgroup2&quot; successfully created</pre><p>Logical volumes</p><p>To create logical volumes, you use the lvcreate command, you also need to specify the logical volume size, name and which VG should the storage be allocated from.</p><p>Logical volumes can be assigned space in two ways.</p><ul><li>Specifying size using extents -l NO. OF EXTENTS.</li><li>Specifying size using units -L SIZE.</li></ul><p>Below is an example</p><pre>$ lvcreate -n my_lv -L 250MiB my_volgroup #using unit size</pre><pre>$ lvcreate -n my_lv2 -l 48 my_volgroup2 #using NO. of extents</pre><p><em>The default physical exent size is 4MiB, thus physical extent of 48 gives 48*4 = 192 MIB</em></p><h4>Creating a File System on Logical volumes</h4><p>To make use of the allocated space, we’ll need to create a file system. creating a file system on logical volumes is the same as creating a file system on a physical device. It is possible to make use of tools provided in linux to create file systems. We’ll be using the <a href="https://linuxhandbook.com/mkfs-command/">mkfs utility</a> to help us.</p><p>To provide the device path, We can use the traditional /dev/vgname/lvname format. Althought there is an alternative to use the kernel device mapper name which takes the format /de/mapper/vgname-lvname.</p><p>To create a xfs file system on the my_lv logical volume, we can do:</p><pre>$ mkfs.xfs /dev/my_volgroup/my_lv</pre><p>To create an ext4 file system on the my_lv2 logical volume, we do:</p><pre>$ mkfs.ext4 /dev/my_volgroup2/my_lv2</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d54e0357ea84" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Batch OS]]></title>
            <link>https://medium.com/@stevenyasimi01/the-batch-os-dda7c01238f2?source=rss-c89f803a7cdf------2</link>
            <guid isPermaLink="false">https://medium.com/p/dda7c01238f2</guid>
            <category><![CDATA[operating-systems]]></category>
            <dc:creator><![CDATA[Nerfed]]></dc:creator>
            <pubDate>Fri, 09 Oct 2026 18:13:33 GMT</pubDate>
            <atom:updated>2026-10-09T18:13:33.136Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UWU49n_NARbttkTr" /><figcaption>Photo by <a href="https://unsplash.com/@patrickkonior?utm_source=medium&amp;utm_medium=referral">Patrick Konior</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>The batch operating system handled scheduling of jobs using monitor. To pass control to the monitor, jobs made use of a special language known as the <em>Job control language</em>. Whenever the processor encounters an instruction starting with ‘$’ this meant the job is ready to pass control back to the monitor in order for it to perform a privileged instruction or prepare the next job. There are two way in which the monitor and the computer executed jobs, the first method involved loading the compiler in memory, compiling the program to object code and saving the object in memory. This operation was referred to as <em>“compile, load and go”</em>. If the object code was stored in mass storage, the monitor had to read a special function known as the $LOAD instruction which invokes the loader to load the object program to memory.</p><p>When a user program read input, data was transferred to the program through input routines, these routines were part of the operating system. The input routines checked the nature of instructions, preventing any job from reading a JCL instruction. If this were to happen, an error occurred and control was passed back to the monitor. Some of the other features included;</p><ul><li><em>Memory protection</em>: A running job cannot alter the memory area which had the monitor. If this happened, the processor hardware detects this as an error and control is transferred to the monitor which aborts the job, prints the error and loads the next job.</li><li><em>Timer</em>: A timer prevents the jobs from monopolizing the system. A timer is set once a job starts execution.</li><li><em>Privileged instructions</em>: Some instructions were executed only by the monitor. If the processor encounters a privileged instruction while executing a user program, an error occurred and control was passed to the monitor.</li></ul><p>To solve the problem of executing privileged instructions as a user program, 2 modes of executions were introduced; The kernel mode and the user mode. In user mode, certain memory regions are restricted and cannot be read by the user program thus preventing the execution of some instructions. In kernel mode, which the monitor operates in, allows the execution of privileged instructions and access to memory regions that are restricted, this mode is also known as the <em>system mode</em>.</p><h4>Multiprogrammed batch operating systems</h4><p>Simple batch operating system solved the problem of job sequencing and scheduling, but there is one bottleneck, processor time is being wasted because it is idle during I/O operations. The simple batch operating system did not support multiprogramming, or multitasking. To solve this, more programs need to be loaded in-memory so that, when a job is waiting for I/O, the processor can branch of to a different job.</p><p>The processor relies on interrupts to know when a device controller finishes an I/O operation. But interrupt are not enough, some form of memory management is needed to manage the multiple programs in-memory.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dda7c01238f2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Evolution of the Operating system.]]></title>
            <link>https://medium.com/@stevenyasimi01/evolution-of-the-operating-system-c4645db02b16?source=rss-c89f803a7cdf------2</link>
            <guid isPermaLink="false">https://medium.com/p/c4645db02b16</guid>
            <category><![CDATA[operating-systems]]></category>
            <dc:creator><![CDATA[Nerfed]]></dc:creator>
            <pubDate>Thu, 08 Oct 2026 19:31:12 GMT</pubDate>
            <atom:updated>2026-10-08T19:31:12.512Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*I_Wa6djDxnq97A7r" /><figcaption>Photo by <a href="https://unsplash.com/@museumsvictoria?utm_source=medium&amp;utm_medium=referral">Museums Victoria</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>In the 1940-mid1950s, computers were very manual. And now you talk to it using natural language, uses statistics to give you the right answer, most of the time. <em>enyewe tumetoka mbali</em>. There were no operating systems, you had to write your program on hardware(punch cards), do it using machine code. Weh, you had to interact with the computer’s hardware to the point that you had to toggle switches. If it encountered an error, it would signal using the display lights. If the program proceeded to a normal completion, the output appeared on the printer.</p><p>Since you did not have a fancy program to schedule your jobs efficiently, this resulted in wastage of a computer’s processing time. For instance, when a user signed up for a timeslot, they’d recieve time in 30s’ (minutes). If a user finishes a job in 45 mins, this resulted in the waste of 15mins, and if a user encountered problems and ran out of time, they’d be forced to stop before resolving the problem.</p><p>Jobs were loaded manually, you had to load the compiler, the source code and then saving the compiled program, afterwards you had to load and link your program with common functions. This was done by mounting and dismouting tapes. Now imagine you had an error :(, you’d have to repeat the whole process. During this era, the most common functions, libraries were available as common software for all users. And that my friends was <em>serial processing</em>, get it!, coz the users had access to the computer in series.</p><h3>Batch Processing</h3><p>Due to the expense of running early computers, processor utilization had to be effective and efficient. To solve this issue, the batch OS was developed. It was developed by General Motors. It was used in the <a href="https://link.springer.com/chapter/10.1007/978-1-4757-3510-9_2">IBM 701</a>.</p><p>The batch OS work in a simple way, it had software known as the monitor. This monitor’s job was to load jobs provided by the computer operator. The computer operator’s responsibility was to collect job cards or tapes and batch the jobs sequentialy and input them to the monitor. To execute a job, the monitor read the jobs from the input to the user program area one at a time. Each job had control of the processor till end of execution. After a job finishes executing, it returns control back to the monitor which then loads the next job. Parts of the monitor resided in main memory, this portion was referred to as the resident monitor. When a program loaded and needed functionality of the monitor, it loaded with parts of the monitor as sub-routines.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c4645db02b16" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Operating system]]></title>
            <link>https://medium.com/@stevenyasimi01/the-operating-system-968ed0ac7295?source=rss-c89f803a7cdf------2</link>
            <guid isPermaLink="false">https://medium.com/p/968ed0ac7295</guid>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[operating-systems]]></category>
            <dc:creator><![CDATA[Nerfed]]></dc:creator>
            <pubDate>Wed, 07 Oct 2026 20:11:15 GMT</pubDate>
            <atom:updated>2026-10-07T20:11:15.165Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Yc1fHBr0BnzKEbm8" /><figcaption>Photo by <a href="https://unsplash.com/@ylearchives?utm_source=medium&amp;utm_medium=referral">Yle Archives</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>The operating system is a set of programs that interface the mahine with the application programs. THe operating system controls and dynamically allocated resources to executing programs. In simple words, the operating system is the interface between the application programs and the hardware. It is also responsible for executing application programs.</p><p>The operating system is useful because;</p><ul><li>It makes a computer more convenient to use</li><li>It allows the computer to be used efficiently</li></ul><p>Operting systems also need to be able to evolve in such a way that new system functions are able to be added and tested.</p><h3>The interface</h3><p>We say the OS is the interface between application programs and the hardware because, an application program can simply make use systems programs which have been developed to handle some functions like file management and control of I/O devices. If an application programmer were responsible for programing this, they will need to write machine level instructions in the application, and most of these functions are reused by other appliactions as well. To simplify this, the OS provides these functionalities through libraries by making use of APIs. Programs that have been built to hand these cases are called <em>Utilities or library programs</em>.</p><p>The OS provides the following services;</p><ul><li><strong>Program development:</strong> The OS provides facilities such as editors and debuggers to assist programmers in creating programs.</li><li><strong>Program execution:</strong> The OS handles tasks such as loading a program from disk to main-memory, initializing I/O device files and other resources.</li><li><strong>Access to I/O devices:</strong> The OS provides a uniform interface that hides details of control signals and peculiar instructions for I/O devices, exposing these functions to the programmers as simple reads/writes.</li><li><strong>Control access to files:</strong> In a multi-user envronment, the OS provides protection of individual users’ files so that other users cannot access files that do not belong to them or have access permissions.</li><li><strong>Error detection and response:</strong> While running a program, an error can occur, these errors might be hardware errors, memory related issues, software errors or a program requesting access to a resticted memory space. It is the OS’s responsibility to handle this error and provide a response. It may responed in various ways including, stoping the program, reporting the error to the program or retrying the operation.</li><li><strong>Accounting:</strong> The OS should be able to account, provide statistics of the system resources and monitor perfomance.</li></ul><p>The operating system is a suite of programs, this means that it is executed by the processor along side other programs. The OS directs the processor in the utilization of system resources and in the timing of execution of programs. The operating system will release the processor to go do some work <em>e.g executing programs</em>, normally on a fixed amount of time then it get’s the processor back. Only potions of the frequently accessed part of the OS source code/ software suite remains in memory at a time.</p><p>Since the processor is a system resource, the OS must determine how much processor time can be devoted to execution of a particular user program.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=968ed0ac7295" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Memory Hierarchy]]></title>
            <link>https://medium.com/@stevenyasimi01/memory-hierarchy-152d45798c3d?source=rss-c89f803a7cdf------2</link>
            <guid isPermaLink="false">https://medium.com/p/152d45798c3d</guid>
            <category><![CDATA[operating-systems]]></category>
            <dc:creator><![CDATA[Nerfed]]></dc:creator>
            <pubDate>Tue, 06 Oct 2026 19:32:13 GMT</pubDate>
            <atom:updated>2026-10-06T19:35:32.432Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CNf6pRJiOyTl3HM-" /><figcaption>Photo by <a href="https://unsplash.com/@crichmond?utm_source=medium&amp;utm_medium=referral">Claud Richmond</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><em>memories…</em></p><p>Memory is a crucial resource, and should be utilized well. Memory comes with three constraints. How fast? how much? and how expensive?</p><p>There are some conditions you have to consider when designing memory, these include;</p><ul><li>Faster access time, greater cost per bit.</li><li>Greater capacity, smaller cost per bit.</li><li>Greater capacity, slower access speed.</li></ul><p>To take advantage of all 3 pros, designers have come up with a <em>memory hierarcy</em>. In this hierarchy, memory is organised in such a way that the smaller, faster and expesive memory is supplemented by larger cheaper memory. As you go down the hierarcy you find that you are decreasing the cost per bit, increasing the capacity and decreasing frequency of access to the memory by the processor.</p><h4>Terms to remember</h4><ul><li><strong>Hit ratio:</strong> The rate of success of memory requests that have been serviced by the smaller, faster memory layer. e.g the cache without needing lookup from slower memory.</li><li><strong>Locality of reference</strong>: The principle of locality, if particular information is fetched from a certain memory region, there’s a possibility that that whole <em>‘cluster’</em> might be used again by the processor. locality if reference uses the same concept.</li><li><strong>Memory cycle time</strong>: The time it takes to write/read one word to/from memory.</li></ul><h3>Cache Memory</h3><p>Funny enough, this memory is invidisible to the OS and interacts with memory management hardware.</p><p>The processor executes instructions as fast as the memory cycle time allows it, this means the processor can be fast but the memory cannot keep up; processor speeds increase rapidly than memory access speeds. Why can’t we build memory that matches the processor’s registers? well it’s expensive. A better solution is to use the principle of locality and provide small, fast memory between the processor and the main memory, the <em>cache</em>.</p><p>You can have multiple levels of the cache ie L1, L2, L3 caches.</p><p>Main memory consists of fixed size blocks containing K words each. When the processor attempts to read a byte or word from memory, the cache is checked first, if it contains the word, the word is passed to the processor. If not, a block of main memory consisting of a fixed number of bytes is read from main memory and placed in the cache, then the word is passed to the processor.</p><p>A cache consists of slots or lines of k words each, the number of slots is less than the number of main memory blocks. If a word is not found in the cache and read from the a main memory block, the entire block is moved to one of the slots in the cache. Since these slots are shared, each slot contains a tag that identifies which block is currently being stored.</p><blockquote>The tag is usually some number of higher-order bits of the address and refers to all addresses that begin with that sequence of bits. eg 2-bit flag(01) 0f 6 bits: 011011, 010110, 011010,010111.</blockquote><p><strong>Block size</strong> is the unit of data exchanged between the cache and main memory. As the block size increases, so does the hit ratio, due to the principle of locality. A <em>mapping function</em> determines which location a block will occupy, a <em>replacement algorithm</em> chooses which block to replace. A block that is least lickely to be used in the near future is the preferred candidate. But since predicting that is quite difficult, a policy known as <em>least-recently-used(LRU) algorithm</em> is used. The strategy is to replace blocks that have been in the cache the longest and have not been referenced.</p><p>If contents in a block are altered, these changes need to be written to main memory before replacing it. The <em>write policy</em> dictates when the memory write operation takes place, it can be either;</p><ul><li>Writes occur when the block is altered.</li><li>Writes occur when the block is replaced.</li></ul><p>One reduces memory write operations, the other one leaves data in main memory at an obsolete state.</p><h3>Direct Memory Access (DMA)</h3><p>Before, there were various ways the processor to perform I/O operations.</p><ol><li>Programmed I/O in this mode, the I/O module performs the requested action and sets appropriate bits once done, it does not interruot the processor, rather , the processor needs to keep checking the status of the operation, this degrades the perfomance of the system.</li><li>Interrupt driven I/O: In this mode, the processor issued the I/O command and goes to do something else, the I/O module will interrupt the processor once it’s ready to exchange data. The processor executed the data transfer, then resumes processing. This is better than programmed I/O, the only issue is, it interrupts the processor.</li></ol><p>DMA solves the short coming. A DMA module can be a separate module on the system or the I/O module’s. When the processor needs to read/write a block of data, it delegates to the module and giving it information it needs to handle the operation. Tis information include;</p><ul><li>Whether it’s a read or write.</li><li>Addr of the I/O module involved.</li><li>Starting memory location to read data from or write data to.</li><li>THe number of words to be read or written</li></ul><p>The DMA module transfers an entire block, word by word, once it’s done, it interrupts the processor(only involved at the begining and end).</p><p>The DMA module makes use of the system bus to transfer data, this means the processor can and will sometimes wait the module to complete it’s operations, this is better than handling interrupts. It slows down the processor.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=152d45798c3d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Operating systems]]></title>
            <link>https://medium.com/@stevenyasimi01/operating-systems-471767f0c246?source=rss-c89f803a7cdf------2</link>
            <guid isPermaLink="false">https://medium.com/p/471767f0c246</guid>
            <category><![CDATA[operating-systems]]></category>
            <dc:creator><![CDATA[Nerfed]]></dc:creator>
            <pubDate>Mon, 05 Oct 2026 19:38:40 GMT</pubDate>
            <atom:updated>2026-10-05T19:38:40.173Z</atom:updated>
            <content:encoded><![CDATA[<h4>Microprocessors and how the operating system uses it</h4><p>The computer is made up of several basic elements</p><ul><li>Memory Memory stores data and programs</li><li>Processor This controls the operation of the computer and data processing functions, if there’s only once processor it is refered to as a central processing unit.</li><li>I/O modules These modules move data between the computer and it’s external environment; these include Disk, terminals and communication equipment</li><li>System bus Provides communication among processors, main memory and I/O modules</li></ul><h4>The Micro processor</h4><p>Ah, yes these have helped the evolution of computers. A microprocessor which has a single processor on a single chip. Before, the micro processor was slow than multichip processors, but micro processors have evolved in moving information; this is typically done in sub-nanoseconds, thats fast.</p><p>Microprocessors these days have improved and contain multiple processors in a single chip. Each chip is called a <em>socket</em> and can contain multiple processors called <em>cores</em>, each with multiple levels of memory caches. A laptop can have 2 or 4 cores each with 2 hardware threads, this makes a total of 4–8 logical processors.</p><p>But a computer can have more microprocessors, each one specializing in a different task, for instance, you can have a GPU — for numerial computation of arrays, render graphics etc, you can have DSPs for Digital Signal processing for processing audio or video, CODECS for encoding/decoding information or providing encryption and security.</p><p>But due to improvements in tech and needed support for handhelp devices like your phone, classical microprocessors are giving way to <em>SoC</em> System on chip, where these functionalities handled by different microprocessors(GPU,DSPs,I/O) and caches are put on one single chip.</p><h4>Instructions</h4><p>The processor executes instructions which are stored in memory, the CPU does this in 2 steps; the <strong>fetch</strong>, retrieveing instructions from memory, one at a time and <strong>execution</strong>. To execute a program, these steps are repeated until termination of the program, when the processor is turned off, when there’s an interupt or when an unrecoverable error occurs. This process is known as the <em>instruction cycle</em></p><ul><li>fetch stage</li><li>execute stage</li></ul><p>The processor fetches instructions from main memory in a sequential manner. To keep track of the next instruction, the processor will use a memory slot inside it called a <em>program counter (PC)</em>. After fetching the instruction, it is then loaded into a special register known as the <em>instruction register</em>, the instruction contain bits that specify the action the processor is to take. The program counter is updated to point to the location of the next instruction; the PC moves in a sequential manner, that is it fetches instructions in a linear and sequential manner, but this might not always be the case as some instructions may make the processor fetch the next instruction from a different memory location.</p><p>These instructions fall into the followinf categories.</p><ul><li>Processor — Memory Data may be transfered from the processor to main memory or from memory to the processor</li><li>Processor — I/O Data may be transfered from the processor to or from a peripheral device by transfering btwn processor and I/O module</li><li>Data processing The processor may perform some arithmetic or logical operations on data.</li><li>Control An instruction may soecify that the sequence of execution be altered; the processor might fetch an instruction from location 149 , whichspecifies the next instruction will be from the location 182, thus the processor will set the program counter to 182, thus on the next fetch stage, instruction will be loaded from 182 instead of 150.</li></ul><p>An instructions execution may involve a combination of these actions.</p><p>The processor also contains a register called the <em>Accumulator(AC)</em> which stores results of processing.</p><h4>Interrupt processing</h4><p>An interrupt is anything that changes the sequence of operations on a processor. Interupts disrupt the normal execution of a program in order to service something of higher priority or to process other data as the processor is waiting for an I/O operation to be done.</p><p>Interrupts are important because they make efficient use of the processor. Most I/O devices are slow compared to the processor; million times slower. There are multiple forms of interupts, these include;</p><ul><li>Program interrupt These are generated by running programs, this can be a result of instruction execution eg attempting to execute illegal machine instruction or trying to reference outside a user’s allowed memory space.</li><li>Timer These are generated by a timer within the processor. This allows the OS to perform certain function on a regular basis.</li><li>I/O These are genrated by an I/O controller, to signal completion of an operation or to signal error conditions</li><li>Hardware Failure Generated by a failure, such as poer failure or memory error.</li></ul><h4>Interrupts and the instruction cycle</h4><p>During an I/O operation, the processor doesn’t need to keep waiting for the I/O operation to be done in order to continue executing a user program. Instead the processor does something else while the I/O operation is being done, this can be reading data from computer memory to the I/O device. Once the external device becomes ready to accept data from the processor, the I/O module for that external device sends an interrupt request signal to the processor. The processor responds by suspending the current program branching off to a routine to service the I/O device,known as <em>an interrupt handler</em></p><p>The processor and the OS are responsible for suspending and resuming the user program. Interrupts are accomodated by adding one more stage in the <em>instruction cycle</em>, this stage is known as the <strong>interrupt stage</strong>. During the instruction cycle, in the interupt stage, which is after the execute instruction stage, The processor will check to see if there is any interrupt pending, indicated by the presence of an interrupt signal. If no interrupts are pending,the processor proceeds to the fetch stage and normal execution resumes. If there’s an interrupt, the processor suspends the execution of the current program and executes an <em>interrupt handler routine</em>. This routine is part of the OS, it detemines the nature of the interrupt and performs whatever actions that are needed. Once the routine is complete, the OS can resume normal execution of the user program at the point of interruption. Extra instructions are executed to determine the nature of the interrupt and to decide on the appropriate action.</p><h4>Interrupt processing</h4><p>When an I/O device completes an I/O operation, the followinf sequence of events occur</p><ol><li>The device issues an interrupt signal to the processor.</li><li>The processor finishes executing the current instruction before responding.</li><li>The processor tests for a pending interrupt request, determines there’s one and sends an acknowledgement signal to the device that issued the interrupt. The acknowledgement allows the device to remove the interrupt signal.</li><li>The processor prepares to transfer control to the interrupt routine, it saves the information of the current program so that it can resume executing it once the interrupt is serviced, minimum information is required, the <em>program status word(PSW)</em> and the location of the next instruction. once this information is pushed in the control stack, the CPU transfers control to the interrupt routine.</li><li>The processor loads the program counter with the entry location of the interrupt handling routine that will respond to this interrupt. Depemding on the computer architecture there might be a single program for each type of interrupt or one for each device and each type of interrupt. If there is more than one type of interrupt-handling routine, the processor might determine which to invoke, this information might also be included in the original interrupt signal, or the processor might have to issue a request to the device that issued the interrupt to get a response that contains the needed information.</li><li>Once the interrupted program’s PC and PSW are saved to the control stack, the processor registers The stack pointer is updated to point to the new top of stack, and the program counter is updated to point to the beginning of the interrupt service routine.</li><li>The interrpt handler proceeds to process the interrupt.</li><li>Once the interrupt processing is complete, the saved register values are retrieved from the stack and restored to the registers.</li><li>Finally the PSW and program counter are restored, as a result, the next instruction to be executed wil be from the previusly interrupted program</li></ol><h4>Multiple Interrupts</h4><p>To process multiple interrupts, two options can be taken</p><ol><li>Disable interrupts while an interrupt is being processed, the processor will ignore all interrupt signals until it’s done processing the current one. once done, the processor will re-enable interrupts. In this fasion, interrupts are handled in a strict sequential order.</li></ol><p>The downside is, it doesn’t consider the priority of the various interrupts or the time critical needs.</p><p>2. The other option is to define priorities for interrupts to allow low-priority interrupts to be interrrupted by higher priority interupt handlers</p><pre>I will be uploading and updating the blog from github.<br>The original repo is this one, if you&#39;re interested, kindly follow up here </pre><pre>https://github.com/Snyasimi/Writeups/tree/main/operating_systems</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=471767f0c246" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is Vagrant]]></title>
            <link>https://medium.com/@stevenyasimi01/what-is-vagrant-b907b6f732ee?source=rss-c89f803a7cdf------2</link>
            <guid isPermaLink="false">https://medium.com/p/b907b6f732ee</guid>
            <category><![CDATA[virtual-machine]]></category>
            <category><![CDATA[vagrant]]></category>
            <dc:creator><![CDATA[Nerfed]]></dc:creator>
            <pubDate>Fri, 20 Feb 2026 08:24:03 GMT</pubDate>
            <atom:updated>2026-02-20T08:24:03.637Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5eavPNnaSZFibaWx" /><figcaption>Photo by <a href="https://unsplash.com/@growtika?utm_source=medium&amp;utm_medium=referral">Growtika</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Vagrant is a <strong>command-line utility</strong> that is used for<strong> managing the lifecycle of a virtual machine</strong>. You can think of it as virtual-box or any hypervisor but doesn’t provide a graphical user interface for you to interact with it.</p><p>Vagrant allows you to isolate dependencies and their configurations within a a single disposable environment.</p><p>Well, by now you must be wondering, “ If its a command-line tool for managing VMs, how do i configure the VMs?”</p><p>Well, vagrant does this in an interesting way, It uses files known as <strong>Vagrant file</strong>. This file holds the virtual machine configuration options, from CPU allocations to networking. The file itself uses ruby like syntax. I know ruby programmers are smiling rn, like the gems they are :)</p><p>Something to also keep in mind is that, you can have only one Vagrantfile per project.</p><p>These virtual machines are known as vagrant boxes, you use a vagrant files to configure a vagrant box. Vagrant also allows you to share your boxes, Hashicorp has a public catalog of these boxes just in case you need one.</p><p>Hey, you can even upload one for the public good, just make sure there’re no vulnerabilities when you do, else it’ll become a supply chain attack or something….. Thats what i heard bug-bros call it :) .</p><p>By now you’ve seen the importance of vagrant, its a powerful tool to have in your inventory if youre working with teams, see it allows you to share the vagrantfile and this enables your team-members to recreate the development environment and modify or test your appliaction or anything.</p><p>To connect to these boxes, ssh is commonly used, as it is the quickest way to connect.</p><p>Well, to make sense of all this information, we’ll go through a simple set up tutorial in our next post. Sabascribe to be informed.</p><pre>sudo shutdown now</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b907b6f732ee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploying an app in your fdroid repo]]></title>
            <link>https://medium.com/@stevenyasimi01/deploying-an-app-in-your-fdroid-repo-4941a2267be9?source=rss-c89f803a7cdf------2</link>
            <guid isPermaLink="false">https://medium.com/p/4941a2267be9</guid>
            <dc:creator><![CDATA[Nerfed]]></dc:creator>
            <pubDate>Sat, 07 Feb 2026 11:59:57 GMT</pubDate>
            <atom:updated>2026-02-07T11:59:57.894Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/866/1*SA5qfJyQbFDFmTK3KZ8H2g.jpeg" /></figure><p>In this tutorial, we’ll be going through on how to deploy your own apk or an opensource apk in your fdroid repository.</p><p>If you don’t know how to set up a repo, i’d recommend that you go through this <a href="https://medium.com/@stevenyasimi01/fdroid-server-installations-6456d7a11de6">post </a>showing you how to create a fdroid repo in linux.</p><h4>Prerequisites</h4><ul><li>fdroid server tools</li><li>fdroid</li><li>computer ;)</li><li>An apk file of your choice</li></ul><p>The first thing we are going to do is to get an apk file (mobile application) that we will use to deploy.</p><p>You can download an apk file from here; <a href="https://www.openapk.net/">apk files</a>.</p><p>For me, i decided to download Trailence, an application for tracking, recording and saving hiking records.</p><figure><img alt="Screen shot of Trailence app" src="https://cdn-images-1.medium.com/max/785/1*iRg1gndUTBogqeRdfHKsoA.png" /></figure><p>you can directly download from the website, or you can make use of wget if you’re working in remote server or working in a terminal.</p><p>To download it via wget, we will type the wget command followed by the link to the application.</p><pre>$ sudo wget https://www.openapk.net/trailence/trailence.org/apk/download/Path_to_apk</pre><p>Once you have downloaded the APK file, we need to make it available in our repository by copying the apk file to where our repo is. <br>The repo is initialized where you had ran the following command</p><pre>$ (fdroid) fdroid init</pre><p>If you didn’t set up a repo or don’t know how to, please refer to this <a href="https://medium.com/@stevenyasimi01/fdroid-server-installations-6456d7a11de6">post</a>.</p><h4>Deploying the apk</h4><p>To deploy the apk and make it accessible in your repo, we copy the file to the repo folder and then run</p><pre>$(fdroid) fdroid update -c</pre><p>This command is used to update the repository, the -c option is used to build meta data if none is available.</p><p>Once you run the command you will get the following files in you repo folder</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/998/1*mBWuwkDVNHcQktUm6UiZFQ.png" /></figure><p>once done we will have to store these files in a server so that we can serve them from the internet.<br>We will go over this in our next post.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4941a2267be9" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>