Fifth to Ninth Week of Internship: A Summary

During these five weeks, I continued to deepen my knowledge and skills in software development. From learning about the JIRA for effective project management to exploring new technologies like Laravel Livewire, SSH, and middleware, each week brought valuable insights and experiences. I also learned about best practices for GitHub pull requests and enhanced my ability to think critically and adapt to challenges in the software development world.

Week 5: JIRA, Shell Commands, and Networking Basics

• Day 1: JIRA for Efficient Project Management
  • Understanding JIRA: JIRA helps us manage tasks or tickets in a project. It keeps track of our work progress.
  • Tickets and Endpoints: Tickets have special web addresses called endpoints. Each endpoint is like opening a door to do a specific task.
  • Estimating Project Work: We use story points in JIRA to estimate how hard a task is. It helps us plan better.
  • Effective Communication: Clear communication is important. If we find a problem, we should suggest a solution too.
• Day 2: Unexpected Obstacles and Learning Opportunities
  • This day didn’t go as planned. I had trouble installing GitHub CLI, but I found a way to continue my work.
  • Lesson: Being resourceful and flexible is important in software development. Sometimes things will not go as expected, and we need to adapt.
• Day 3: Shell Commands and Networking Basics
  • I learned about shell commands, which are like magic words for computers.
  • I explored networking basics, including ports and addresses.
  • Lesson: In the shell, different symbols indicate our user role. It’s important to understand these roles.
  • Lesson: Cybersecurity is crucial, and there are patterns and conventions to follow.
  • Lesson: In software development, it’s about skills, not the device or system we use.
• Day 4: Git Configuration and Code Reading
  • I learned how to configure Git using commands like git config --global and git config --local.
  • I discovered the importance of signing Git commits for security.
  • I practiced reading code, a key skill for working on projects.
  • Lesson: Proper Git configuration ensures consistency.
  • Lesson: Signing commits adds security to our work.
  • Lesson: Reading code helps us understand projects better.

Week 6: Git, Shell and Networking

• Day 1: Exploring Git: Branching and Stashing
  • Branching for Organized Development: Git allows us to work on different parts of a project without messing up the main code. We can create separate work areas called branches.
  • Detailed and Verified Commits: When making changes, it’s important to describe them well in our commit messages. Git can track all changes, so honesty is key.
  • Simplified Development: Git makes development organized by letting us work on different parts without confusion.
  • Analyzing Changes with git diff: Git can show differences between versions of our code.
  • git stash: It’s a handy tool for dealing with conflicts in our work.
• Day 2: Middleware, Model, and Controller
  • This day, I learned about middleware, models, and controllers in software development.
• Day 3: Shell Commands and Networking Basics
  • I explored shell commands, which are like magic words for making computers do things. I also learned about computer networks and some essential commands.
  • Ports and Addresses in Networking: Ports are like doors on a computer, and addresses are like unique names for computers.
  • Understanding User Roles in the Shell: We can tell what kind of user we are by looking at the prompt symbol.
  • Cybersecurity: This field is about keeping computers and data safe.
• Day 4: Git Configuration and Code Reading
  • I learned about configuring Git using commands like git config --global and git config --local. This helps us work consistently across different projects.
  • Signing Git Commits: This adds security to our work by verifying our changes.
  • Code Reading: I practiced reading and understanding code, an important skill for working on projects.

Week 7: Addressing System Inconsistencies and Effective Communication

• Day 1: Addressing System Inconsistencies and 5Ws and 1H in Communication
  • Addressing System Inconsistencies: I started my seventh week with a task to identify and fix issues in the admin ticketing system. I worked on a “Bug” issue related to filtering tickets by “Date Submitted” and proposed a solution.
  • Enhancing Communication: I learned about effective communication using the 5Ws and 1H method, which helps make messages clear and informative.
• Day 2: Document Signing and System Brainstorming
  • I didn’t have a coding task on this day. Instead, I visited the office to get my documents signed. While waiting, I discussed potential enhancements to the admin ticketing system with my fellow intern. It was a productive discussion, highlighting the importance of preparation and making good use of my time.
• Day 3: Finding System Issues
  • I was assigned to look for more issues in the admin ticketing system. I identified problems related to responsive design when the browser window is resized. One issue was about tables not getting a horizontal scroll bar, making it hard to view all the information. Another issue involved the profile section exceeding the left navigation area. I reached out to fellow interns for help and solved the issues, learning the value of knowing when to ask for assistance.

Week 8: Bug Reporting, SSH & SCP, and Ticket Etiquette

• Day 1: Bug Reporting and Introduction to SSH/SCP
  • I learned how to report bugs effectively in JIRA by not just identifying issues but also suggesting solutions.
  • In the afternoon, my manager introduced SSH (Secure Shell) and explained its importance in securely accessing and controlling computers or servers over a network.
  • I learned about public and private keys in SSH and their roles in secure authentication.
  • Additionally, SCP (Secure Copy Protocol) was introduced as a secure way to copy files between computers over an SSH connection.
• Day 2: Ticket Etiquette
  • I had to take a half-day off for a rescheduled class.
  • I learned about proper ticket etiquette, emphasizing clear communication in ticket handling, requesting reviews, and holding discussions in JIRA.
• Day 3: Ticket Handling
  • I spent time working on a specific ticket, adding a CSS attribute to an element in the project.
  • I submitted a pull request for my changes, informed my mentor, and updated the ticket in JIRA.
  • This experience highlighted the importance of clear communication and staying organized in tasks.
• Day 4: A Valuable Lesson in Handling a Ticket
  • I faced a ticket that needed fixing and initially used a JavaScript solution, but my mentor pointed out potential issues if JavaScript was disabled.
  • The day’s main task was reviewing the entire admin ticketing system to identify issues affecting its functionality, not just its appearance.
  • I learned that problem-solving in software development requires finding the right solution that works in all situations.

Week 9: GitHub Pull Requests, Laravel Livewire, SSH, and Middleware

• Day 1: GitHub Pull Requests and Best Practices
  • My manager emphasized the importance of linking GitHub pull requests to related Jira tickets and vice versa.
  • I made changes to two tickets, learning the significance of considering different scenarios and best practices, such as separating styles from inline CSS.
  • I explored draft pull requests, a way to manage changes before they are ready for review.
• Day 2: Exploring Laravel Livewire
  • I began learning about Laravel Livewire, a tool for building dynamic web applications in Laravel.
  • I installed Livewire and did some exercises, including creating components, nesting them, and handling events and actions.
• Day 3: Laravel Livewire and SSH
  • I continued exploring Laravel Livewire and refreshed my knowledge of SSH.
  • I read the SSH documentation, gaining familiarity with commands like ssh-keygen, ssh-add, and scp.
• Day 4: Middleware
  • The focus was on understanding middleware in Laravel and its purpose, which is like a filter for web applications.
  • I learned that middleware can handle tasks such as authentication and input validation.
  • Middleware should contain logic and configuration but should not directly access databases or render views.
  • I explored two types of middleware: global middleware that applies universally and route middleware for specific rules on certain pages or actions, enhancing security and control in our web application.