Site Title

recent posts

about

  • Business and S.Development : Payment Processing

    Oct 24th, 2026

    For this blog, I chose to watch the video “How Does Payment Processing Work? – How Software Companies Monetize Payments” from CCSalesPro to learn more about how payment processing works and how software companies can make money from it. The video explains the different roles involved in payment processing, including the cardholder, merchant, independent software vendor (ISV), and payment processor. It also discusses the fees associated with processing payments and how software companies can earn additional revenue by integrating payment processing into their platforms. I chose this topic because I wanted to learn more about how software companies that deal with apps/websites that manage transactions, because they’re interesting and, I have been asked to help design a website that uses a payment page.

    One of the main reasons I chose this resources was because I wanted to explore more areas of software development that I haven’t encountered yet. Since most businesses use software to manage payments and other transactions, I thought that It would be profitable to learn how those systems work and how they can benefit the companies that provide them. This video was great because it made clear the overlap between software development and business in a way that was easy to understand.

    A key takeaway from the video is that payment processing involves several costs, including interchange fees paid to banks and fees charged by card networks like Visa and Mastercard. The video explains that software companies can earn revenue by integrating payment processing into their platforms and capturing a portion of the processing revenue. For example, a merchant that processing $50,000 a month could generate an additional $1,000 a month for a software provider if it captures a %2 margin. Understanding this showed me that payment processing can become a significant source of income for software companies.

    Reflecting on what I learned, I realized that I didn’t consider how much business strategy is involved in software development. I thought more about software in terms of the features it provides and the problems it solves. This video showed me that software companies also need to consider how their products generate revenue and support their long-term growth. Its interesting and very useful to see how adding a service that customers already need can create another business opportunity.

    I expect that this knowledge will be incredibly useful in my future career because understanding the business side of software can help me see the bigger picture when working on projects. It also made me more interested in learning how payment systems are developed and integrated into applications.

    Overall, this resource gave me a better understanding of payment processing and how software companies can monetize it. It helped me recognize the connection between technology and business and gave me knowledge that I can build on in future coursework and professional projects.

    Resource:

    CCSalesPro. “How Does Payment Processing Work? – How Software Companies Monetize Payments.” https://www.youtube.com/watch?v=Prz_-sleFBE

  • Exploring REST APIs

    October 5th, 2026

    For this blog, I chose to watch the video “What is a REST API?” from IBM Technology to learn more about an interesting topic that we have not covered in the course yet. The video starts with an introduction to REST APIs and explains how they allow different software applications and systems to communicate with each other. It also explains concepts like clients, servers, HTTP requests, and the different methods used to interact with them. I chose this topic because APIs are something I have heard about before, but I did not have a strong understanding of how they actually work or why they are important in software development.

    One of the main reasons I selected this resource was because I wanted to explore something outside of the material we have covered so far. Since REST APIs are commonly used in software development, I thought learning the basics would give me a better understanding of how applications work together. The video was also a good choice because it explained the concepts in a way that was clear and easy to understand. As someone planning to work in software development, I wanted to understand a technology that I will likely need in future projects and professional settings.

    A key takeaway from the video is that an API provides a way for different applications to communicate without needing to know how each other works. REST APIs use HTTP methods such as GET, PUT, POST, and DELETE to create, retrieve, update, or remove information. This was interesting, as it helped me understand what is going on behind the scenes when different applications exchange information. For example, an application can request information from a server and receive a response without having to manage the database or processes that produced that information.

    Reflecting on what I learned, I realized that I had previously thought of applications as mostly separate programs. Learning about REST APIs showed me how connected software systems actually are. Many of the applications and websites I use every day depend on APIs to communicate with other services and exchange information. It made me realize that there is a lot more communication between different parts of an application than I thought.

    I expect this knowledge to be useful in my future career because understanding how systems communicate is an important part of software development. Even though REST APIs have not yet been covered in our course, learning about them before the class topic comes up gives me a foundation that I can build on when we learn these concepts. It also made me want to learn more about how APIs are actually created and used in real applications.

    Overall, this resource gave me a better understanding of REST APIs and their role in modern software development. It helped me see how different systems can work together and gave me knowledge that I can expect to apply to future coursework and professional projects.

    Resource:

    IBM Technology. “What is a REST API?” https://www.youtube.com/watch?v=lsMQRaeKNDk

  • Intro blog for CS-343

    Hello CS-343, this is my blog page for this class.

  • The Importance of Software Maintenance

    For this week’s blog, I chose two resources that helped me better understand the concept of software maintenance: a GeeksforGeeks article on the topic and a YouTube video titled “Types of Software Maintenance (Corrective, Adaptive, Perfective, and Preventive).” Both resources directly relate to what we have been covering in class about the software development lifecycle and the importance of writing clean, effective, and maintainable code.

    Summary of the resources
     The GeeksforGeeks article provides a clear explanation of what software maintenance truly involves, and it makes the point that maintenance is much more than simply fixing bugs that appear after deployment. The article breaks maintenance into four major categories and explains the role each plays in the long-term health of a software system. Corrective maintenance deals with identifying and resolving defects found by users or testers. Adaptive maintenance focuses on updating the software so it can function in new environments, such as new operating systems or hardware. Perfective maintenance involves improving performance or adding new features based on user feedback. Preventive maintenance aims to reduce the likelihood of future failures by improving the structure of the code or addressing small issues before they escalate. The article also highlights common challenges, such as outdated codebases, lack of documentation, and the difficulty of maintaining systems that were not designed with long-term updates in mind. One of the most important points it makes is that planning for maintenance should start during development, not after release.

    The YouTube video supports this information by providing simple and practical examples of the same four maintenance types. Each type is explained using real-world scenarios that make the concepts easier to understand. Because the video is short, direct, and visually presented, it reinforced the definitions from the article and helped me remember them more clearly. The combination of written explanation and visual examples was especially helpful, since I tend to understand topics better when I can learn them in multiple formats.

    Why I chose these resources
     I chose these resources because together they gave me a well-rounded understanding of software maintenance. The article offered depth and detail, while the video provided clarity and accessible examples. Using both helped me see not just what maintenance is, but why it matters so much in real projects. I also realized how important maintainability is as a design principle. Clean code, proper naming, updated documentation, and thoughtful structure all directly impact how easy a system is to update later. Maintenance isn’t optional or something to think about only after deployment, it is a constant part of the software’s life. If code is messy or poorly organized, future developers including myself may struggle to understand it.

    Overall, these resources helped me build a stronger understanding of the maintenance phase of the software development lifecycle. They made me more aware of how much responsibility developers still have after a product is launched and why maintainability should be taken seriously from the very beginning.

    Links
    GeeksforGeeks article: https://www.geeksforgeeks.org/software-engineering/software-engineering-software-maintenance/
    YouTube video: https://www.youtube.com/watch?v=_8aNZZaaoSQ

  • Strategic Process Modeling

    For this blog, I selected two resources to better understand software process models, a central topic in our course on software engineering. The first resource, “Top 8 Software Development Models Used in Industry” from GeeksforGeeks, outlines the most commonly used models in the software industry, including Agile, Waterfall, V-Model, Incremental, RAD, Iterative, Spiral, and Prototype. The article For this blog, I selected two resources to better understand software process models since they are central to our course on software process management. The first resource, “Top 8 Software Development Models Used in Industry” from GeeksforGeeks, introduces commonly used models such as Agile, Waterfall, V-Model, Incremental, RAD, Iterative, Spiral, and Prototype. The article gives a clear explanation of each model’s purpose, how its phases are structured, the benefits it offers, and the project types where it performs best. The second resource, the Institute of Data article “Understand Software Process Models,” provides an overview of SDLC frameworks and emphasizes how choosing the right model depends on factors like requirement stability, risk, and deadlines.

    I chose these two resources because together they offer both an industry-oriented perspective and a more academic explanation. This combination allowed me to see how these models function in real teams while also understanding the theory behind why they were created. As someone planning to work in software development, I wanted a stronger grasp of how teams select a process model and what trade offs come with each approach.

    A major takeaway from these readings is that no single model works best for every project. Agile, for example, uses short iterations that make it ideal for projects with changing or unclear requirements. Waterfall, on the other hand, follows a strict linear sequence, making it more suitable when requirements are stable and thoroughly documented. The Spiral model adds a heavy focus on risk analysis, which is helpful for large or high uncertainty projects. Models like RAD and Prototype show how useful rapid prototyping can be when quick feedback is needed or when requirements are fuzzy at the start. Understanding these differences helped me see that software development is not just about writing code, it also depends heavily on planning, teamwork, and communication.

    The GeeksforGeeks article breaks down several widely used models: Agile emphasizes adaptability and customer feedback; Waterfall uses a clear phase by phase structure; the V-Model pairs each development stage with a corresponding testing phase; the Incremental model delivers functionality in small pieces; RAD focuses on fast prototyping; the Iterative model refines the system through repeated cycles; the Spiral model prioritizes risk management; and the Prototype model helps clarify uncertain requirements. Seeing the strengths and weaknesses of each helped me understand why teams might choose one model over another.

    Reflecting on my own coursework, I realize that I often rushed into development without a well defined plan. Going forward, I plan to evaluate requirements more carefully. For example, in a project where features may evolve, I would recommend an Agile or Iterative approach, while a project with fixed objectives might benefit from Waterfall or Incremental development. This kind of planning can make teamwork smoother and lead to better overall results.

    Overall, these resources strengthened my understanding of software process models and how they apply to real world software development. They helped me connect class concepts with professional practice and prepare for future roles in the field.

    Resources:

  • The importance of a well-rounded development environment paired with a friendly team culture.

    As programmers, having a well configured development environment is not just convenient, it is essential. The tools we choose determine how efficiently we can write, test, and share code. Integrated Development Environments (IDEs), version control systems, and containerization tools form the foundation of a modern workflow, and understanding how to properly use and configure them is one of the first responsibilities of any developer. IDEs come in several forms, desktop IDEs that run locally and support multiple languages, cloud-based IDEs that run in the browser and allow real-time collaboration, and language-specific IDEs designed for particular ecosystems. Knowing these options and recognizing which ones match your needs helps streamline your entire workflow.

    For example, I primarily use Visual Studio Code, a desktop IDE known for its flexibility and support for many languages and extensions. When I pair VS Code with GitHub for version control and Docker for containerization, I end up with a development environment that is both stable and reproducible. Git helps me manage and track versions of my code, making it easy to revert changes or collaborate with others. Docker ensures that my local environment and the production environment match, preventing dependency conflicts that often cause “it works on my machine” issues. Without tools like these, developers must manually configure editors, debuggers, build tools, and version tracking systems, which not only wastes time but also introduces unnecessary complexity. IDEs, version control, and containers automate repetitive tasks and reduce human error, allowing us to focus on writing high-quality and maintainable software.

    An article I reviewed, SpeedScale: Modern Development Environment Playbook, supports these points. The article defines a development environment as a comprehensive setup of both software and hardware tools that enable programmers to work effectively. It explains how tools like IDEs, version control, and automation systems significantly increase productivity by simplifying and accelerating routine development tasks. SpeedScale organizes the process of setting up a strong environment into four steps: choosing an IDE, configuring version control, implementing build automation, and customizing your IDE. Their breakdown reinforces the idea that a good environment is not created by accident, it requires intentional planning.

    Additionally, I watched a video focused on avoiding toxic team culture in software development. While tools shape our workflow, team culture shapes how we interact, communicate, and make decisions. The video emphasizes that healthy cultures are built on trust, shared goals, open communication, and constructive feedback. Toxic cultures, by contrast, emerge from inconsistent leadership, unrealistic expectations, and environments where people fear failure or blame one another. When teams feel safe, supported, and aligned, the quality of the software improves along with morale. Together, these two sources highlight that effective software engineering is not just about tools or culture alone, but the combination of a strong technical foundation and a healthy, collaborative team environment..

  • Hello World!

    Welcome to WordPress! This is your first post. Edit or delete it to take the first step in your blogging journey.

  • Hello Computer Science Class!

    This is my blog, making sure all the tags and connections are successful.

Create your own website, free on WordPress.com.Create your own website.
Start free