<?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 Pius Gandhi on Medium]]></title>
        <description><![CDATA[Stories by Pius Gandhi on Medium]]></description>
        <link>https://medium.com/@muapius21?source=rss-865ddc5101bf------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dmbNkD5D-u45r44go_cf0g.png</url>
            <title>Stories by Pius Gandhi on Medium</title>
            <link>https://medium.com/@muapius21?source=rss-865ddc5101bf------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 05:08:24 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@muapius21/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[Learning Linux Commands and Shell Scripting: My Journey Through the Command Line]]></title>
            <link>https://medium.com/@muapius21/learning-linux-commands-and-shell-scripting-my-journey-through-the-command-line-25bb02033940?source=rss-865ddc5101bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/25bb02033940</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Pius Gandhi]]></dc:creator>
            <pubDate>Wed, 21 Oct 2026 07:29:51 GMT</pubDate>
            <atom:updated>2026-10-21T07:29:51.533Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5vCu57T-l0HNNHc2_gV_OA.jpeg" /></figure><p>As I continue my journey through the <strong>IBM DevOps and Software Engineering Professional Certificate</strong> on Coursera, I’ve completed another course: <strong>Hands-on Introduction to Linux Commands and Shell Scripting</strong>.</p><p>This course introduced me to several practical concepts that have helped me better understand Linux and the role the command line plays in working with computer systems. Although I learned a lot, I see this as one of the courses I’ll need to revisit to strengthen my understanding and become more comfortable using the terminal.</p><h3>Getting More Comfortable with Linux</h3><p>One of the areas covered in the course was the Linux operating system and how to interact with it through the terminal. I explored basic commands for navigating the file system, creating and managing files and directories, and viewing file contents.</p><p>I also learned about file permissions and ownership, including how permissions determine who can read, modify, or execute files. These concepts helped me appreciate that working with Linux involves more than knowing commands; it also requires understanding how files are organized and how access is controlled.</p><h3>Exploring Shell Scripting and Automation</h3><p>Another important part of the course was <strong>Bash shell scripting</strong>. I was introduced to the idea of combining commands in a script to carry out tasks instead of performing every step manually.</p><p>The lessons covered concepts such as variables, user input, input and output redirection, command-line arguments, and file permissions for executable scripts. I also explored how scheduled tasks can be configured using cron.</p><p>I’m still learning how to put these concepts together confidently, but I can already see how shell scripting can help simplify repetitive tasks and make certain processes more efficient. The hands-on exercises provided opportunities to practise what I was learning, including working with scripts and exploring how tasks can be automated.</p><h3>My Biggest Takeaway</h3><p>One thing that stood out to me is that <strong>command-line skills and automation are important foundations for working with Linux systems and DevOps tools</strong>.</p><p>Before taking this course, I had some familiarity with technical concepts, but this learning experience helped me see more clearly how commands and scripts can be used to interact with a system and automate routine operations. It also reminded me that understanding a concept while studying it is only one part of learning; practising it repeatedly is what helps build confidence.</p><p>Interestingly, I’ve learned so much from this course that I sometimes feel like talking through the command line! Still, I know I have more to practise before I can say I’m comfortable with everything covered.</p><h3>What Comes Next?</h3><p>I plan to revisit this course, practise the commands, and spend more time working in the terminal. My goal is not simply to complete the lessons but to develop a practical understanding that I can build on as I progress in DevOps and software engineering.</p><p>Every course in this journey gives me another opportunity to learn something new, revisit what I already know, and identify areas where I need more practice.</p><p>For now, I’m glad to have completed this course, and I look forward to continuing the journey, one concept and one command at a time.</p><p>6 courses down, 9 more to go🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=25bb02033940" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Getting Started With Git and GitHub: Understanding Version Control and Collaboration]]></title>
            <link>https://medium.com/@muapius21/getting-started-with-git-and-github-understanding-version-control-and-collaboration-42afe3d2d909?source=rss-865ddc5101bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/42afe3d2d909</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Pius Gandhi]]></dc:creator>
            <pubDate>Mon, 12 Oct 2026 13:15:05 GMT</pubDate>
            <atom:updated>2026-10-12T13:15:05.003Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qNN2LgtVFjCmyyYgpgN2_Q.jpeg" /></figure><p>As I continue my learning journey through the <strong>IBM DevOps and Software Engineering Professional Certificate on Coursera</strong>, I have completed the fifth course, <strong>Getting Started With Git and GitHub</strong>.</p><p>Software development involves more than writing code and building applications. It also requires a reliable way to track changes, manage different versions of a project, collaborate with other developers, and ensure that individual contributions can be integrated without disrupting existing work.</p><p>These needs become even more important when several people are working on the same project. Without a proper system for managing changes, developers may overwrite one another’s work, lose important versions of files, or struggle to identify when and why a problem was introduced.</p><p>This course introduced me to the fundamentals of version control using Git and GitHub. Through the lessons and practical activities, I explored how repositories are managed, how changes are recorded, how branches support parallel development, and how developers collaborate through pull requests.</p><p>One of my main takeaways is that <strong>version control is not simply about storing code; it is about managing change and making collaboration more structured, transparent, and reliable.</strong></p><h3>1. Understanding Git and GitHub</h3><p>One of the first concepts covered in the course was the distinction between Git and GitHub. Although the two are closely related and often mentioned together, they serve different purposes.</p><p><strong>Git is a distributed version control system</strong> that helps developers track changes to files over time. It maintains a history of a project, allowing developers to record updates, review previous versions, and work on different versions of a project.</p><p><strong>GitHub is an online platform for hosting Git repositories.</strong> It provides a central place where developers can store projects, share their work, collaborate with others, and review proposed changes.</p><p>In simple terms, Git helps manage the history of a project, while GitHub provides a platform for sharing and collaborating on that project.</p><p>This distinction is important because Git can be used locally on a computer without GitHub. GitHub, however, builds on Git by making repositories accessible online and providing collaboration features.</p><p>The course also introduced distributed version control. Instead of relying exclusively on one central copy of a project, developers can maintain local copies of repositories and their history. This supports independent work while making it possible to share and integrate changes with a remote repository.</p><h3>Why version control matters</h3><p>Imagine working on an application for several weeks. You make changes to its files, add new features, and correct errors. Later, you discover that one of your updates has caused another feature to stop working.</p><p>Without version control, identifying the problematic change could be difficult. You might have to depend on manually saved copies of files or attempt to reconstruct what you changed.</p><p>With Git, changes can be recorded as commits, allowing you to inspect the project’s history and better understand how it has evolved.</p><p>For teams, this provides additional benefits. Developers can track contributions, review changes, and work together with greater accountability.</p><p>Version control is therefore a foundational skill for software developers and an important part of collaborative software engineering.</p><h3>2. Repositories, Commits, and Project History</h3><p>Another important concept I learned was how repositories and commits work together to organize a software project.</p><p>A <strong>repository</strong>, commonly called a <em>repo</em>, is where a project’s files and version history are maintained. A repository can contain source code, documentation, configuration files, and other resources associated with a project.</p><p>GitHub allows users to create repositories through its web interface. Files can then be added, edited, or uploaded directly to the repository.</p><p>A <strong>commit</strong> records a set of changes to the project. It acts as a checkpoint in the project’s history and usually includes a message describing the changes made.</p><p>For example, a developer working on a school management application might make separate commits for fixing a login error, updating the dashboard, and improving the documentation.</p><p>Rather than treating the entire project as one constantly changing collection of files, these commits create a more understandable record of its development.</p><h3>The importance of meaningful commit messages</h3><p>A commit is more useful when its message clearly explains the change.</p><p>For example, a message such as <em>“Fix login validation error”</em> is more informative than <em>“Updates”</em> or <em>“Changes made.”</em></p><p>Meaningful commit messages help developers understand the project’s history without having to inspect every file in detail.</p><p>This is particularly valuable when working in teams or returning to a project after several weeks or months.</p><p>The broader lesson is that good version control involves not only recording changes but also documenting them in a way that other people can understand.</p><h3>3. Branches: Working on Changes Without Disrupting the Main Project</h3><p>Branches were another key topic in the course.</p><p>A <strong>branch</strong> provides a separate line of development within a Git repository. It allows developers to work on a feature, experiment with an improvement, or fix a bug without making those changes directly in the main development line.</p><p>Consider a team developing an online learning platform. One developer is responsible for improving the user profile page, while another is working on the course registration feature.</p><p>Branches allow both developers to work on their respective tasks without immediately mixing their changes with the main branch.</p><p>Once the work is ready, the changes can be reviewed and integrated into the main project.</p><p>This approach makes development more organized and reduces the risk of disrupting the existing codebase while new work is in progress.</p><h3>Merging branches</h3><p>After completing work on a branch, a developer may merge it into another branch.</p><p><strong>Merging combines changes from different branches into a shared line of development.</strong></p><p>For example, after completing and testing a new feature, a developer can merge the feature branch into the main branch so that the feature becomes part of the project.</p><p>However, merging requires attention. If two branches modify the same part of a file in incompatible ways, Git may report a merge conflict that needs to be resolved before the changes can be integrated.</p><p>This illustrates why branches are useful, but also why developers must understand how their changes interact with the rest of a project.</p><h3>4. Pull Requests and Collaborative Development</h3><p>While branches help developers work independently, teams also need a way to propose, discuss, and review changes before integrating them into a shared project.</p><p>This is where <strong>pull requests</strong> become useful.</p><p>A pull request is a proposal to merge changes from one branch into another. On GitHub, it provides a space for collaborators to examine the proposed changes, discuss the implementation, provide feedback, and decide whether the changes are ready to be merged.</p><p>For instance, a developer who has completed a bug fix can open a pull request asking the team to review the changes before they become part of the main branch.</p><p>This process encourages collaboration and provides an opportunity to identify potential problems before the changes are integrated.</p><p>Pull requests also help make development decisions more transparent. Team members can see what was changed, discuss why it was changed, and leave feedback that may help improve the final result.</p><p>The relationship between branches, pull requests, and merging is especially important in collaborative software development:</p><p><strong>i. Branches</strong> provide space to work on changes independently.</p><p><strong>ii. Pull requests</strong> allow proposed changes to be reviewed and discussed.</p><p><strong>iii. Merging</strong> integrates the approved changes into the target branch.</p><p>Together, these practices provide a structured way to contribute to shared projects.</p><h3>5. Working With Git Through the Command Line</h3><p>The course also introduced Git commands, showing how version control can be managed through a command-line interface (CLI), in addition to using GitHub’s web interface.</p><p>The command line provides a direct way to interact with repositories and perform common version control operations. These commands form part of a typical Git workflow.</p><p>For example, after editing a file, a developer can check the repository’s status, stage the changes, commit them with a meaningful message, and push the commit to a remote repository.</p><p>The command line may initially appear unfamiliar to someone who has mostly interacted with software through graphical interfaces. However, learning these commands makes it possible to manage repositories directly and understand the operations behind many version control workflows.</p><p>The course helped connect the concepts of repositories, commits, branches, and remote collaboration to practical Git commands.</p><h3>6. Cloning and Forking Repositories</h3><p>Another useful part of the course was learning about cloning and forking repositories.</p><p>Although both are commonly used when working with existing projects, they serve different purposes.</p><p><strong>Cloning</strong> creates a local copy of a repository on your computer. This allows you to inspect the project, work on its files, create commits, and interact with the remote repository according to your permissions.</p><p>For example, a developer can clone a project from GitHub to their local development environment, make changes, and push those changes to a remote repository if they have the necessary access.</p><p><strong>Forking</strong> creates a separate copy of a repository under another GitHub account. It is particularly useful when contributing to projects that you do not directly control.</p><p>A contributor can fork a public repository, clone the fork to their computer, make changes on a separate branch, and push those changes to their fork. They can then open a pull request proposing that the original project incorporate their contribution.</p><p>This workflow is especially useful in open-source development, where contributors from different backgrounds and locations can collaborate without needing direct write access to the original repository.</p><p>Understanding the difference between cloning and forking helped clarify how developers can participate in existing projects while maintaining a suitable level of independence.</p><h3>7. Synchronizing Local and Remote Repositories</h3><p>Software projects often exist in both local and remote environments.</p><p>The local repository is the copy maintained on a developer’s computer, while the remote repository is hosted on a platform such as GitHub.</p><p>When working independently, a developer may make commits locally before pushing them to the remote repository. In a team environment, other contributors may also push changes to the shared remote repository.</p><p>This means developers need to understand how to synchronize their work.</p><p>The git push command sends local commits to a remote repository, while git pull retrieves remote changes and integrates them into the current branch.</p><p>These operations help keep local and remote versions of a project aligned.</p><p>However, synchronization is not simply a matter of sending files back and forth. Developers must pay attention to the branch they are working on, the changes made by other contributors, and any conflicts that arise when different changes cannot be combined automatically.</p><p>The course’s practical exercises reinforced the importance of understanding the relationship between local work and shared repositories.</p><h3>8. Applying the Concepts Through Hands-On Activities</h3><p>For me, one of the important aspects of this course was the opportunity to connect the theoretical concepts to practical workflows.</p><p>The activities involved using GitHub’s web interface and Git’s command-line interface to manage repositories and work with changes.</p><p>The course’s final project included two parts, allowing the concepts to be applied through both interfaces. The activities covered creating and managing repositories, adding and committing files, pushing changes, and working with branches.</p><p>The command-line exercises also involved cloning a forked repository, creating a branch to fix a typo in a README file, committing and pushing the change, and merging the branch into the main branch. Another task involved reverting a change and submitting a pull request.</p><p>These exercises demonstrated that version control is not just about learning individual commands. It is about understanding how the different operations fit together within a workflow.</p><p>For example, fixing a typo in a project may appear simple, but when working collaboratively, the process can involve creating a branch, editing the file, committing the change, pushing the branch, reviewing the proposed update, and merging it into the appropriate branch.</p><p>Learning this workflow provides a foundation for participating in real software projects, where even small changes need to be managed carefully.</p><h3>9. An Introduction to GitHub Copilot</h3><p>The course also introduced GitHub Copilot as an optional topic.</p><p>GitHub Copilot is an AI-powered coding assistant that provides contextual code suggestions and autocomplete functionality within supported development environments.</p><p>It can suggest lines or blocks of code based on the context of a project, help generate common code structures, and reduce the time spent writing repetitive code.</p><p>For example, while writing a function, a developer may receive suggestions for how to complete the function based on its name and surrounding code.</p><p>However, the course emphasized an important point: <strong>AI-generated code still requires human review and testing.</strong></p><p>A developer should not automatically accept every suggestion. The generated code must be checked against the project’s requirements, tested to confirm that it behaves as expected, and reviewed for quality and security.</p><p>GitHub Copilot is a tool to assist development, not a replacement for understanding the code being written.</p><p>I found this to be a relevant reminder as AI tools become increasingly integrated into software development. Using these tools effectively requires more than knowing how to generate code; it also requires the ability to evaluate the output, recognize potential problems, and take responsibility for the final result.</p><h3>10. My Key Takeaways From the Course</h3><p>Looking back at the course, several lessons stood out to me.</p><p><strong>Version control is a fundamental software development skill.</strong> It provides a structured way to track changes, maintain project history, and understand how a project has evolved over time.</p><p><strong>Collaboration requires a clear workflow.</strong> Branches, pull requests, reviews, and merges help developers contribute to shared projects without making every change directly to the main codebase.</p><p><strong>Git and GitHub serve complementary purposes.</strong> Understanding the distinction between the version control system and the platform used to host and collaborate on repositories makes it easier to understand the wider workflow.</p><p><strong>Practical experience matters.</strong> Learning what a command does is useful, but applying it within a complete workflow helps build a clearer understanding of how version control operates.</p><p>Finally, tools continue to evolve, including the introduction of AI coding assistants. Nevertheless, developers still need sound judgment, an understanding of software development principles, and a willingness to review and test their work.</p><p>These lessons are relevant not only to software engineers but also to other technical professionals who contribute to projects involving code, configuration files, documentation, or collaborative development.</p><h3>Conclusion: Building a Foundation for Collaborative Software Development</h3><p>Completing <em>Getting Started With Git and GitHub</em> has helped me strengthen my understanding of how software changes are managed and how developers collaborate on shared projects.</p><p>The course brought together several concepts that are essential to a typical development workflow: repositories, commits, branches, pull requests, cloning, forking, merging, and synchronization between local and remote repositories.</p><p>More importantly, it helped me see how these concepts work together to support an organized development process.</p><p>As I continue through the IBM DevOps and Software Engineering Professional Certificate, I am building on the foundations introduced in earlier courses, including DevOps, Cloud Computing, Agile Development and Scrum, and Software Engineering.</p><p>Each course contributes a different perspective on how software is planned, developed, managed, and delivered. Git and GitHub add another important piece by showing how changes can be tracked and collaborative work coordinated.</p><p>My next step is to continue practicing these concepts and applying them to projects as I progress through the remaining courses.</p><p><strong>5 courses down, 10 more to go🚀</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=42afe3d2d909" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introduction to Software Engineering: Revisiting the Foundations and Seeing the Bigger Picture]]></title>
            <link>https://medium.com/@muapius21/introduction-to-software-engineering-revisiting-the-foundations-and-seeing-the-bigger-picture-e10dbb2a333a?source=rss-865ddc5101bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/e10dbb2a333a</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[computer-science]]></category>
            <dc:creator><![CDATA[Pius Gandhi]]></dc:creator>
            <pubDate>Tue, 06 Oct 2026 11:06:54 GMT</pubDate>
            <atom:updated>2026-10-06T11:06:54.155Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xmmpjkoTa-MfyXv1XywN_A.jpeg" /></figure><p>I have just completed the <strong>Introduction to Software Engineering</strong> course on Coursera as part of my journey through the <strong>IBM DevOps and Software Engineering Professional Certificate</strong>.</p><p>This is the fourth course I have completed in the program, with <strong>11 more courses to go</strong>.</p><p>Coming into this course, I expected to encounter quite a few familiar concepts because I studied Software Engineering during my Bachelor’s degree. That turned out to be the case. Many of the topics served as a useful refresher, but going through them again in a structured course also helped me connect some of these concepts more clearly. I also encountered ideas and perspectives that were new to me. Here are some of the things that stood out to me.</p><h3>1. Software Engineering Is More Than Writing Code</h3><p>One of the things the course reinforced for me is that <strong>software engineering is much broader than programming</strong>.</p><p>Before software is written, there is a need to understand the problem being solved, identify the people who will use or be affected by the system, gather requirements, design the solution, test it, document it, deploy it, and continue maintaining it.</p><p>The course also highlighted the distinction between a software developer and a software engineer. While the terms are often used interchangeably, the course presented software engineers as taking a broader, more systematic view of software development and the systems being built.</p><p>This was a useful reminder that writing code is only one part of the larger software engineering process.</p><h3>2. Revisiting the Software Development Life Cycle</h3><p>The <strong>Software Development Life Cycle (SDLC)</strong> was one of the major areas covered in the course.</p><p>I revisited the different stages involved in developing software, including requirements gathering, design, coding, testing, release, and documentation.</p><p>The course also explored different approaches to implementing the SDLC, including <strong>Waterfall, the V-Model, and Agile</strong>.</p><p>Having recently completed the <em>Introduction to Agile Development and Scrum</em> course in this certificate, it was particularly useful to see Agile again from the broader perspective of the software development life cycle.</p><p>I was also reminded of the importance of requirements gathering. Requirements are not simply a list of features that someone wants in a system. They need to be identified, elicited, analyzed, documented, prioritized, and confirmed.</p><p>The course introduced documents such as the <strong>User Requirement Specification (URS), Software Requirement Specification (SRS), and System Requirement Specification (SysRS)</strong> and explained how they are used to describe different aspects of a system’s requirements.</p><p>This reinforced something important for me: <strong>good software development starts with understanding what needs to be built and why.</strong></p><h3>3. A Refresher on Software Development and Its Tools</h3><p>Another part of the course looked at how software applications are developed, particularly web and cloud applications.</p><p>I revisited the relationship between the <strong>front-end and back-end</strong> of an application. The front-end is concerned with what users see and interact with, while the back-end handles the logic, data processing, authentication, and other operations that happen behind the scenes.</p><p>The course also covered technologies such as <strong>HTML, CSS, and JavaScript</strong>, as well as programming languages, frameworks, libraries, code editors, IDEs, and version control systems.</p><p>One concept I found particularly relevant to my current learning journey was <strong>Continuous Integration and Continuous Delivery/Deployment (CI/CD)</strong>. The course explained how these practices help development teams integrate, build, test, and deliver software changes more reliably.</p><p>This connected naturally with the DevOps concepts I encountered in the first course of this professional certificate.</p><h3>4. Revisiting Programming Fundamentals</h3><p>The programming module took me back to some of the fundamental concepts behind software development.</p><p>It covered programming languages and the differences between <strong>interpreted and compiled languages</strong>, as well as programming constructs, functions, objects, and different programming approaches.</p><p>I also revisited <strong>Object-Oriented Programming (OOP)</strong> and concepts such as classes and objects.</p><p>Although these were not completely new concepts for me, revisiting them helped reinforce the foundation behind many of the technologies used in software development today.</p><p>The course also discussed development practices such as pair programming and the use of tools that support developers throughout the development process.</p><h3>5. Understanding Software Architecture and Design</h3><p>The section on <strong>software architecture, design, and patterns</strong> was another area I found valuable.</p><p>It introduced concepts such as structured design, behavioral models, UML diagrams, and <strong>Object-Oriented Analysis and Design (OOAD)</strong>.</p><p>I revisited UML diagrams and how they can help developers visualize the structure and behavior of a system before and during implementation.</p><p>The course also explored different architectural approaches, including <strong>two-tier, three-tier, event-driven, peer-to-peer, and microservices architectures</strong>.</p><p>Another useful area was the discussion of different application environments, such as <strong>development, quality assurance, staging, and production</strong>.</p><p>These concepts helped me see how the different pieces of a software system fit together beyond the actual source code.</p><h3>6. Software Testing and Quality</h3><p>The course also reinforced the importance of testing in software engineering.</p><p>I revisited different types of testing, including <strong>functional, non-functional, and regression testing</strong>, as well as testing levels such as unit, integration, system, and acceptance testing.</p><p>What stood out to me is that testing is not simply about finding bugs after development is finished. It is part of the broader process of ensuring that a software solution behaves as expected and continues to work when changes are introduced.</p><p>The course also emphasized documentation, covering areas such as requirements documentation, design documentation, technical documentation, quality assurance documentation, and user documentation.</p><p>These are areas that can easily be overlooked when the focus is placed mainly on writing code, but they are important for maintaining and understanding software over time.</p><h3>7. Software Engineering Has Many Career Paths</h3><p>The final module gave me an opportunity to think about software engineering from a career perspective.</p><p>The course introduced different roles within the field, including <strong>front-end engineering, back-end engineering, full-stack development, DevOps, software quality assurance, software integration, software security, mobile development, and game development</strong>.</p><p>It also discussed the technical and managerial paths that a software engineer can take as their career develops.</p><p>One point I particularly appreciated was that the skills gained in software engineering can also be transferred to other areas of technology.</p><p>Depending on a person’s interests and strengths, software engineering experience can provide a foundation for moving into areas such as technical support, technical sales, data-related roles, database administration, testing, or leadership.</p><p>This was a useful reminder that a career in technology does not necessarily have to follow one fixed path.</p><h3>8. Technical Skills Are Only Part of the Picture</h3><p>The course also distinguished between <strong>hard skills and soft skills</strong>.</p><p>Technical skills such as programming, version control, cloud computing, testing, debugging, monitoring, troubleshooting, Agile development, and database architecture are important.</p><p>However, software engineers also need skills such as <strong>communication, teamwork, problem solving, adaptability, and collaboration</strong>.</p><p>This resonated with me because software development is rarely an individual activity. Engineers often work with other developers, designers, project managers, stakeholders, clients, and people from other technical and non-technical departments.</p><p>Being able to communicate an idea, understand another person’s perspective, receive feedback, and work effectively with others can be just as important as technical knowledge.</p><h3>9. The Importance of Professional Ethics</h3><p>Another part of the course that I found meaningful was the discussion of <strong>software engineering ethics</strong>.</p><p>The course introduced eight principles covering:</p><p>i. Public</p><p>ii. Client/Employer</p><p>iii. Product</p><p>iv. Judgment</p><p>v. Management</p><p>vi. Profession</p><p>vii. Colleagues</p><p>viii. Self</p><p>These principles emphasize responsibilities such as protecting the public interest, acting honestly toward clients and employers, producing quality software, maintaining professional judgment, treating colleagues fairly, and continuing to develop professionally.</p><p>For me, this was a reminder that the systems we build can affect real people. Software engineering therefore involves not only technical decisions, but also responsibility.</p><h3>My Main Takeaway</h3><p>Perhaps my biggest takeaway from this course is that <strong>software engineering is a complete discipline rather than simply the act of programming</strong>.</p><p>The different topics connect to one another.</p><p>Requirements influence design.<br>Design influences implementation.<br>Implementation requires testing.<br>Testing supports quality.<br>Documentation helps people understand and maintain the system.<br>Architecture influences how a system grows and performs.<br>And all of these activities involve communication and collaboration.</p><p>Because I had already studied many of these concepts during my Bachelor’s degree, the course was partly a process of revisiting familiar ground. However, revisiting those concepts in a different learning environment helped me look at them from another perspective and connect them with the DevOps, Cloud, and Agile concepts I have encountered earlier in this professional certificate.</p><p>It also reminded me that learning in technology does not end when a degree is completed.</p><p>There is always something to revisit, something to understand better, and something new to learn.</p><p>I am now moving on to the next course in the certificate.</p><p><strong>4 courses down and 11 more to go🚀</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e10dbb2a333a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Learning to Build, and Improve in Iterations]]></title>
            <link>https://medium.com/@muapius21/learning-to-build-and-improve-in-iterations-06bcd4e8cb74?source=rss-865ddc5101bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/06bcd4e8cb74</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[agile-development]]></category>
            <category><![CDATA[scrum]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Pius Gandhi]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 13:03:25 GMT</pubDate>
            <atom:updated>2026-09-28T13:03:25.238Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WsZmfPdWvylCGoqNMjFcLg.jpeg" /></figure><p><strong>Software development is not only about building something. It is also about learning what to build, learning from feedback, and continuously finding better ways to deliver value.</strong></p><p>As I continued my journey through the <strong>IBM DevOps and Software Engineering Professional Certificate</strong>, I recently completed my third course, <strong>Introduction to Agile Development and Scrum</strong>.</p><p>Before taking this course, I had already encountered the word <em>Agile</em> several times in software development. I understood that Agile involved flexibility, teamwork, iterations, and responding to change. However, going through the course gave me a much deeper understanding of what Agile really means and how it can be applied through frameworks such as Scrum.</p><p>What made the course particularly interesting for me was that it moved beyond definitions. It connected Agile principles to practical activities such as writing user stories, refining product backlogs, planning sprints, using Kanban boards, conducting daily stand-ups, reviewing completed work, reflecting through retrospectives, and measuring progress.</p><p>The course was organized into four major areas:</p><p>A. Introduction to Agile and Scrum</p><p>B. Agile Planning</p><p>C. Daily Execution</p><p>D. Practical labs using GitHub Projects/ZenHub</p><p>Here are some of the lessons that stood out to me throughout the course.</p><h3>Agile Is More Than a Methodology</h3><p>One of my biggest takeaways from the course is that <strong>Agile is first a philosophy and a way of thinking about how work is approached.</strong></p><p>Agile encourages teams to avoid trying to predict and plan every detail of a project far into the future. Instead, teams work in smaller increments, deliver something useful, gather feedback, learn from it, and adjust accordingly.</p><p>This approach is built around ideas such as:</p><p>i. Adaptive planning</p><p>ii. Iterative development</p><p>iii. Early delivery of value</p><p>iv. Customer collaboration</p><p>v. Continuous feedback</p><p>vi. Continuous improvement</p><p>This changed the way I think about software development.</p><p>A project does not necessarily become successful because the original plan was followed perfectly. Sometimes, the original plan itself needs to change because the team has learned something new.</p><p>Agile therefore creates room for learning.</p><p>Instead of asking only:</p><p><strong><em>“Did we follow the plan?”</em></strong></p><p>the team can also ask:</p><p><strong><em>“What have we learned, and what should we do next?”</em></strong></p><p>That distinction was particularly meaningful to me.</p><h3>From Waterfall to Agile Thinking</h3><p>The course also helped me understand how Agile compares with other approaches to software development.</p><p>One of the approaches discussed was <strong>Waterfall</strong>, which follows a more structured, sequential process. While this can be useful in certain situations, one challenge is that problems or misunderstandings may not become visible until much later in the development process.</p><p>Agile takes a different approach.</p><p>Rather than waiting until the end to discover whether the product meets customer expectations, Agile encourages teams to deliver smaller increments and obtain feedback earlier.</p><p>The course also introduced <strong>Extreme Programming (XP)</strong> and <strong>Kanban</strong>.</p><p>XP emphasizes practices such as simplicity, communication, feedback, respect, and courage. It also includes practices such as Test-Driven Development and pair programming.</p><p>Kanban, on the other hand, focuses heavily on visualizing workflow, limiting work in progress, improving flow, making process policies explicit, and continuously improving the process.</p><p>Learning about these approaches helped me understand that Agile is not simply one specific process. It is a broader philosophy that can be supported by different practices and frameworks.</p><h3>Agile and Scrum Are Not the Same Thing</h3><p>Another important distinction I learned was the difference between <strong>Agile and Scrum</strong>.</p><p>Before this course, I sometimes encountered the two terms together and assumed they were essentially interchangeable.</p><p>They are not.</p><p>The course explains Agile as a philosophy, while <strong>Scrum provides a structured framework for working in an Agile way</strong>.</p><p>Scrum introduces defined roles, events, artifacts, rules, and fixed-length iterations known as <strong>sprints</strong>.</p><p>The goal is to help a small, cross-functional, self-managing team work toward delivering a potentially shippable product increment during each sprint.</p><p>This distinction made Scrum much easier for me to understand.</p><p>If Agile provides the mindset, Scrum provides a framework through which that mindset can be practiced.</p><h3>Understanding the People Behind Scrum</h3><p>One of the most interesting parts of the course was learning about the different responsibilities within a Scrum team.</p><h3>The Product Owner</h3><p>The <strong>Product Owner</strong> represents stakeholders and is responsible for product vision, priorities, requirements, and deciding whether completed work is ready to move forward.</p><p>The Product Owner also plays an important role in maintaining and refining the product backlog so that stories are ready for future sprints.</p><h3>The Scrum Master</h3><p>The <strong>Scrum Master</strong> facilitates the Scrum process and coaches the team.</p><p>One point that stood out to me was that the Scrum Master is not simply a person who assigns tasks or tells everyone what to do.</p><p>Instead, the Scrum Master helps create an environment where the team can organize itself, removes impediments, protects the team from unnecessary interference, and helps the team continuously improve.</p><h3>The Development Team</h3><p>The development team is responsible for determining how to accomplish the work committed to during a sprint.</p><p>The course emphasized the importance of having teams that are <strong>small, dedicated, cross-functional, collaborative, and self-managing</strong>.</p><p>This reinforced an important idea for me: effective software development is not simply about having talented individuals. The way those individuals work together matters just as much.</p><h3>Planning Without Trying to Predict Everything</h3><p>One misconception I had about Agile was that being flexible might mean having less planning.</p><p>The course helped me see that Agile actually involves <strong>a lot of planning</strong>, but the planning happens at different levels and remains adaptable.</p><p>A major part of this is the <strong>product backlog</strong>.</p><p>The product backlog contains the work that may need to be done for the product. But it is not simply a random list of tasks. It needs to be ordered, clarified, refined, and continuously updated.</p><p>This is where <strong>backlog refinement</strong> becomes important.</p><p>Large or vague items can be broken down into smaller stories and clarified so that they can eventually become ready for a sprint.</p><p>The goal is not to make the entire future perfectly predictable.</p><p>The goal is to make the next piece of work clear enough to execute.</p><p>That is a subtle difference, but an important one.</p><h3>User Stories: Seeing Features Through the User’s Eyes</h3><p>Another concept I learned was the use of <strong>user stories</strong>.</p><p>Instead of describing a feature only in technical language, a user story describes what a user needs and why.</p><p>The course presents the structure:</p><p><strong>“As a [role], I need [function], so that [benefit].”</strong></p><p>For example:</p><p><strong>As a customer, I need to view available products, so that I can decide what I want to purchase.</strong></p><p>This simple structure helps connect development work to user needs.</p><p>It reminds the team that behind every feature is a person who is expected to receive some form of value from it.</p><p>I also learned about the <strong>INVEST</strong> principle for user stories, including the importance of stories being independent.</p><p>Writing good user stories therefore requires more than simply describing a technical task. It requires thinking about the user, the function they need, and the value that function provides.</p><h3>Story Points and the Idea of Velocity</h3><p>Another concept that caught my attention was <strong>story points</strong>.</p><p>Story points are used to estimate the relative amount of work involved in completing a story.</p><p>What I found interesting is that story points are not simply measurements of hours.</p><p>They provide a way for a team to consider the relative complexity, effort, and uncertainty associated with different pieces of work.</p><p>This leads to another important Scrum concept: <strong>velocity</strong>.</p><p>Velocity refers to the number of story points a team can complete during a sprint.</p><p>For example, if a team has historically completed around 18 story points in a sprint, it can use that information when planning the next sprint instead of simply adding as much work as possible.</p><p>This encourages teams to plan based on what they have demonstrated they can realistically accomplish.</p><p>In other words:</p><p><strong>Agile planning is not about making the biggest promise. It is about making a realistic commitment and learning from experience.</strong></p><h3>The Kanban Board: Making Work Visible</h3><p>I also gained practical experience with <strong>Kanban boards</strong>.</p><p>A Kanban board provides a visual representation of work as it moves through different stages.</p><p>Instead of simply telling someone that a task is being worked on, the board allows the entire team to see its status.</p><p>For example, work can move from a backlog into an active or <strong>In Progress</strong> state and eventually toward completion.</p><p>This may seem simple, but visualization creates transparency.</p><p>Team members can see what is being worked on, what remains to be done, and where work may be getting stuck.</p><p>The course also emphasized the importance of not working on too many stories simultaneously. When team members focus on the next highest-priority item they are able to work on, the workflow becomes easier to understand and manage.</p><h3>The Sprint: Turning Plans Into Action</h3><p>Once planning is complete, the team moves into the <strong>sprint</strong>.</p><p>A sprint is a fixed-length iteration during which the team works toward a specific goal.</p><p>The course described the sprint as an iteration through activities such as design, coding, testing, and deployment.</p><p>One thing I appreciated about this approach is that the sprint gives the team a clear focus.</p><p>Rather than thinking about everything that might need to be done over several months, the team asks:</p><p><strong>What valuable work can we accomplish during this iteration?</strong></p><p>That creates a manageable cycle of planning, execution, feedback, and improvement.</p><h3>The Daily Stand-Up</h3><p>The <strong>daily stand-up</strong> is another important part of Scrum.</p><p>The course presented three central questions:</p><p>1. What did I work on yesterday?</p><p>2. What am I working on today?</p><p>3. Are there any blockers or impediments?</p><p>What I found interesting is that the stand-up is not simply a meeting for reporting progress to a manager.</p><p>It is intended to help the team understand where everyone is, identify obstacles, and maintain alignment.</p><p>If someone is blocked, the team can recognize the problem rather than allowing it to remain hidden.</p><p>This connects directly to the role of the Scrum Master, whose responsibility includes helping remove impediments that prevent the team from progressing.</p><h3>Sprint Review: Letting Stakeholders See the Work</h3><p>At the end of a sprint comes the <strong>sprint review</strong>.</p><p>This is essentially a demonstration of what the team has built during the sprint.</p><p>Stakeholders and customers can participate and provide feedback.</p><p>This is important because a team can spend considerable time building something that technically works but does not fully address what the customer actually needs.</p><p>Feedback provides an opportunity to correct course.</p><p>The product backlog can then be updated based on what is learned during the review.</p><p>This reinforced one of the central principles of Agile for me:</p><p><strong>Feedback is not an interruption to development. Feedback is part of development.</strong></p><h3>The Retrospective: Improving the Way We Work</h3><p>If the sprint review focuses primarily on the product, the <strong>sprint retrospective</strong> focuses on the team and its process.</p><p>The team reflects on questions such as:</p><p>i. What went well?</p><p>ii. What did not go well?</p><p>iii. What should we change for the next sprint?</p><p>I particularly appreciated this part of the course because it demonstrates that Agile is not only about delivering software faster.</p><p>It is also about becoming better at delivering software.</p><p>A retrospective should not simply become a meeting where people complain about problems and then return to work unchanged.</p><p>The purpose is improvement.</p><p>If the team identifies a problem, something should change as a result of that reflection.</p><p>That creates a continuous cycle:</p><p><strong>Work → Reflect → Learn → Improve → Work again.</strong></p><h3>Measuring What Actually Matters</h3><p>The course also introduced me to the importance of using <strong>actionable metrics</strong> rather than relying on metrics that simply look impressive.</p><p>Four actionable metrics highlighted in the course were:</p><p><strong>Mean Lead Time:</strong> How long it takes to move from an idea to production.</p><p><strong>Release Frequency:</strong> How often changes can be delivered.</p><p><strong>Change Failure Rate:</strong> How often changes fail.</p><p><strong>Mean Time to Recovery (MTTR):</strong> How quickly the team can recover from a failure.</p><p>The important lesson here is that measurement should support improvement.</p><p>A number is not automatically useful simply because it is easy to measure.</p><p>The team needs metrics that help it understand performance and make better decisions.</p><h3>Agile Anti-Patterns: Learning What Not to Do</h3><p>Another valuable part of the course was learning about common <strong>Agile and Scrum anti-patterns</strong>.</p><p>Some of the problems discussed included:</p><p>Having no real Product Owner</p><p>Having teams that are too large</p><p>Having team members who are not dedicated</p><p>Excessive geographical distribution</p><p>Teams working in silos</p><p>Teams that are not self-managing</p><p>This was a useful reminder that simply adopting Agile terminology does not automatically make an organization Agile.</p><p>A team can have stand-ups, sprints, backlogs, and Kanban boards and still fail to embrace the principles behind them.</p><p>The way people collaborate, communicate, make decisions, and respond to feedback is just as important as the tools they use.</p><h3>What This Course Changed in My Perspective</h3><p>Completing this course has changed the way I think about software development.</p><p>Previously, I might have looked at a software project primarily from the perspective of the product being built.</p><p>Now I am beginning to see the importance of the <strong>process through which the product is built</strong>.</p><p>A successful development process requires more than technical skills.</p><p>It requires communication.</p><p>It requires prioritization.</p><p>It requires collaboration.</p><p>It requires feedback.</p><p>It requires transparency.</p><p>It requires adaptability.</p><p>And perhaps most importantly, it requires a willingness to improve.</p><p>I also see a stronger connection between what I learned in this course and what I learned in my previous <strong>Introduction to DevOps</strong> course.</p><p>DevOps emphasized collaboration, shared responsibility, small batches, early feedback, automation, and continuous delivery.</p><p>Agile provides many of the principles and practices that help teams organize their work around those ideas.</p><p>This connection is helping me understand why these topics are part of the same learning journey.</p><h3>My Biggest Takeaway</h3><p>If I had to summarize this entire course in one idea, it would be this:</p><p><strong>You do not have to get everything right on the first attempt. You need a process that allows you to learn, adapt, and improve.</strong></p><p>That is what makes the iterative nature of Agile so powerful.</p><p>You start with what you know.</p><p>You build something useful.</p><p>You listen to feedback.</p><p>You examine what happened.</p><p>You learn.</p><p>Then you improve the next iteration.</p><p>And you repeat the cycle.</p><p>For me, this is more than a software development practice. It is also a valuable approach to learning itself.</p><p>As I continue developing my technical and professional skills, I am realizing that progress does not always come from trying to create the perfect result immediately.</p><p>Sometimes, progress comes from taking the next meaningful step, learning from it, and becoming better in the next iteration.</p><p>Completing <strong>Introduction to Agile Development and Scrum</strong> marks another milestone in my journey through the <strong>IBM DevOps and Software Engineering Professional Certificate</strong>.</p><p>From DevOps culture, to Cloud Computing, and now Agile and Scrum, each course is adding another piece to my understanding of how modern software is planned, developed, delivered, and continuously improved.</p><p>There is still a long way to go, but I am enjoying the process of learning one course at a time.</p><p><strong>3 courses down, 12 more to go🚀</strong></p><p>The journey continues.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=06bcd4e8cb74" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What I Learned from Introduction to Cloud Computing Course]]></title>
            <link>https://medium.com/@muapius21/what-i-learned-from-introduction-to-cloud-computing-course-aabfb6ec3c46?source=rss-865ddc5101bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/aabfb6ec3c46</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Pius Gandhi]]></dc:creator>
            <pubDate>Mon, 21 Sep 2026 10:01:16 GMT</pubDate>
            <atom:updated>2026-09-21T10:01:16.712Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/469/1*so9h4r7_LoBtOwovHxNeTg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4AaMeUsqlNw4QkUXVbyuwQ.jpeg" /><figcaption>Source: v2soft.com</figcaption></figure><p>When I started the course, I already had a general understanding of what cloud computing meant. I knew that companies could use cloud platforms to host applications, store data, and access computing resources without necessarily owning and managing all the physical infrastructure themselves.</p><p>But this course showed me that cloud computing is much broader than that.</p><p>It gave me a foundation for understanding not only <strong>what the cloud is,</strong> but also why organizations use it, how it works, what technologies make it possible, how applications are designed for the cloud, how cloud environments are secured, and what career opportunities exist within the field.</p><h3>Cloud computing is more than infrastructure</h3><p>One of the first things I learned was the essential characteristics of cloud computing.</p><p>Cloud resources can be provisioned on demand, accessed over a network, shared through resource pooling, scaled up or down according to demand, and measured based on usage.</p><p>This helped me understand why the cloud has become so important to modern organizations.</p><p>Imagine a business experiencing a sudden increase in customers. With traditional infrastructure, responding to that increase could require purchasing and configuring additional physical hardware. Cloud computing makes it possible to increase resources much more quickly and then reduce them when demand falls.</p><p>That flexibility is one of the things that makes cloud computing so powerful.</p><p>I also learned about the evolution of cloud computing, from the early days of mainframes and time-sharing to virtualization, hypervisors, shared infrastructure, and today’s cloud platforms.</p><h3>Understanding what is happening underneath the cloud</h3><p>Another important part of the course was learning about cloud infrastructure.</p><p>I explored concepts such as:</p><p>· Virtual machines</p><p>· Hypervisors</p><p>· Bare-metal servers</p><p>· Regions and Availability Zones</p><p>· Cloud networking</p><p>· Containers</p><p>· Load balancing</p><p>· Auto-scaling</p><p>Before this course, some of these concepts existed as technical terms I had encountered but did not fully understand.</p><p>Now I have a clearer picture of how they relate to one another and how cloud providers use them to deliver computing resources.</p><p>I also learned about different cloud storage technologies, including <strong>Direct Attached Storage, File Storage, Block Storage, and Object Storage</strong>.</p><p>What stood out to me was that there isn’t one storage solution that is ideal for every situation.</p><p>This made me realize that cloud computing isn’t simply about knowing different technologies. It is also about understanding <strong>when and why to use each one</strong>.</p><p>Another major concept I learned was the difference between the three major cloud service models:</p><p><strong>Infrastructure as a Service (IaaS)</strong> provides fundamental computing resources such as servers, storage, and networking.</p><p><strong>Platform as a Service (PaaS)</strong> provides a more complete environment for developing, deploying, and managing applications while abstracting much of the underlying infrastructure.</p><p><strong>Software as a Service (SaaS)</strong> provides users with access to cloud-based software without requiring them to manage the underlying infrastructure.</p><p>Understanding these models helped me see the cloud as a spectrum of responsibility.</p><p>The more infrastructure a provider manages for you, the less you have to manage yourself. At the same time, you give up some control over the underlying environment.</p><p>That balance between <strong>control, responsibility, convenience, and cost</strong> is something I will continue thinking about as I learn more about cloud technologies.</p><h3>Cloud and emerging technologies</h3><p>One of the most interesting sections of the course was exploring how cloud computing supports emerging technologies.</p><p>I learned about the relationship between cloud computing and:</p><p><strong>Internet of Things (IoT)</strong> : Where connected devices continuously generate data that needs to be stored and processed.</p><p><strong>Artificial Intelligence:</strong> Where scalable computing resources can support the processing of large amounts of data and the development of AI-powered applications.</p><p><strong>Blockchain:</strong> Where cloud infrastructure can provide the distributed and scalable computing resources needed to support blockchain applications.</p><p><strong>Data analytics:</strong> Where cloud platforms provide the computing and storage capabilities required to process large datasets and generate useful insights.</p><p>What stood out to me was that these technologies don’t necessarily exist independently.</p><h3>From traditional applications to cloud-native applications</h3><p>The course also introduced me to <strong>cloud-native application development</strong>.</p><p>I learned about concepts such as <strong>microservices, containers, serverless computing, and application modernization</strong>.</p><p>One idea that stood out was the difference between a large monolithic application and a collection of smaller, loosely coupled services.</p><p>Instead of building everything as one large piece of software, microservices allow an application to be broken down into smaller components that can be developed, deployed, and managed independently.</p><p>Containers provide another layer of flexibility by packaging applications and their dependencies in a consistent environment.</p><p>Serverless computing takes another approach by allowing developers to run functions without having to manage the underlying servers directly.</p><p>These concepts helped me understand why modern cloud applications are often designed differently from traditional applications.</p><h3>Where DevOps fits in</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*Hj1ZnOWdDloEbOS1TzejBg.jpeg" /><figcaption>Source: shalb.com</figcaption></figure><p>Since this course is part of the IBM DevOps and Software Engineering Professional Certificate, I found the connection between <strong>cloud and DevOps</strong> particularly relevant.</p><p>Cloud environments provide the infrastructure, platforms, and services needed to build and run applications at scale.</p><p>DevOps provides practices that help teams collaborate, automate processes, continuously integrate and deliver software, monitor applications, and respond to changes.</p><p>This reinforced something I learned in my previous course, <strong>Introduction to DevOps</strong>: technology alone is not enough. The way teams work and collaborate matters too.</p><p>The cloud gives organizations powerful capabilities, but DevOps helps teams use those capabilities effectively.</p><h3>Security cannot be an afterthought</h3><p>Another important lesson was cloud security.</p><p>I was introduced to concepts including:</p><p>· Identity and Access Management (IAM)</p><p>· Cloud encryption</p><p>· Security monitoring</p><p>· Access groups</p><p>· Network security</p><p>· Compliance</p><p>· The shared responsibility model</p><p>One thing that became clear to me is that moving infrastructure to the cloud does not mean that security becomes someone else’s problem.</p><p>Understanding who is responsible for what is therefore an important part of working with cloud technologies.</p><h3>Seeing the career possibilities</h3><p>The course also opened my eyes to how broad the cloud computing field really is.</p><p>I learned about roles such as:</p><p>· Cloud Software Engineer</p><p>· Cloud Integration Specialist</p><p>· Cloud Data Engineer</p><p>· Cloud Security Engineer</p><p>· Cloud DevOps Engineer</p><p>· Cloud Solutions Architect</p><p>This was particularly valuable to me because I am still exploring where I want to develop professionally within the broader technology space.</p><p>The course made me realize that <strong>cloud computing is not a single career path</strong>. There are different specializations, each requiring different combinations of technical knowledge and skills.</p><h3>What I am taking forward</h3><p>If I had to summarize this entire course in one sentence, I would say:</p><p><strong>Cloud computing is not simply about putting applications or files “in the cloud”; it is about using computing resources and modern technologies in a flexible, scalable, and efficient way to create value.</strong></p><p>I don’t consider myself an expert in cloud computing after completing one course. Instead, I see this as a foundation upon which I can build.</p><p>For now, I’m happy to pause, reflect on what I’ve learned, and then keep moving forward.</p><p><strong>Two courses completed. Thirteen more to go</strong>🚀</p><p>The journey continues.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aabfb6ec3c46" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introduction to DeVops]]></title>
            <link>https://medium.com/@muapius21/introduction-to-devops-784d9f4d9065?source=rss-865ddc5101bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/784d9f4d9065</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Pius Gandhi]]></dc:creator>
            <pubDate>Thu, 10 Sep 2026 08:45:08 GMT</pubDate>
            <atom:updated>2026-09-10T08:45:08.240Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>DevOps is first a culture before it is a technology</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/738/1*MRdgzGlKmsp0KWjcEIvD8Q.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YNQTcvPyLlXcnpc5cRtXPA.jpeg" /><figcaption>courses one certificate</figcaption></figure><p>After completing my first course in the IBM DevOps and Software Engineering Professional Certificate, I learned that DevOps is much more than I initially thought.</p><p>Before taking this course, I associated DevOps mainly with things like automation, deployment, cloud technologies, and tools. But this course helped me understand that <strong><em>DevOps is first a culture before it is a technology.</em></strong> It requires a willingness to change how you think, how you work, how teams are organized, and even how success is measured.</p><p>One of the ideas that really stood out to me is that development and operations shouldn’t work in separate silos. They need to collaborate throughout the entire software development life cycle, with shared responsibility, accountability, and trust.</p><p>I also learned about the importance of <strong><em>working in small batches and getting feedback early</em>,</strong> rather than waiting until everything is finished before discovering that something went wrong.</p><p>Another concept that stood out to me was <strong>Continuous Integration and Continuous Delivery (CI/CD)</strong>. Instead of treating software as something that is built once and released at the end of a long project, DevOps encourages us to continuously build, test, integrate, and deliver changes.</p><p>I learned why practices like <strong>Test Driven Development (TDD), Behavior Driven Development (BDD), microservices, automation, and actionable metrics</strong> matter. Not simply because they are popular practices and technologies, but because they help teams deliver better software faster and with less waste.</p><p>But perhaps my biggest takeaway is this:</p><p><strong>You don’t simply “do” DevOps. You become DevOps.</strong></p><p>This is only the beginning for me.</p><p>I still have fourteen more courses ahead in this professional certificate, and I’m looking forward to building on this foundation and understanding the technical side of DevOps much more deeply.</p><p>One course completed. Many more lessons ahead.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=784d9f4d9065" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>