In this course, we'll give you the tools to quickly identify and solve real-world problems that you might come across in your IT role. We'll look at a bunch of different strategies and approaches for tackling the most common pitfalls of your code and IT infrastructure. You'll learn strategies for approaching almost any technical problem and then see how those apply to solving different real-world scenarios.
We picked examples that include general system issues, issues with software that someone else wrote, and issues with programs that we wrote. We'll talk about problems that can affect any operating system, and we'll also look at challenges specific to certain platforms and scripting languages.
- Key Concepts
- Understand the concept of troubleshooting
- Grasp what debugging is and how it can help in the troubleshooting process
- Understand how to get to the root cause of a problem
- Utilize the right approach for recurring problems and intermittent problems
- Understand the difference between linear and binary searches
- Search CSV files for invalid data
In this module, you’ll be introduced to the fundamentals of troubleshooting and you’ll learn different strategies and approaches to tackle problems that you might encounter. You’ll learn about the concept of debugging and how debugging is one of the core principles of troubleshooting. You’ll be introduced to some tools that will help you in the debugging process, like tcpdump, ps, top, itrace, and lots more. Next, you’ll explore how to “understand the problem.” This might sound like a no brainer, but it's not as easy as you might think! Next, we’ll dive into the different approaches when troubleshooting reproducing errors versus intermittent errors. Finally, you’ll learn about “binary searching a problem.” We’ll explore the different types of searches, including binary and linear searches. Then, we’ll learn about the concept of bisecting and how it can be used in your troubleshooting approach, and finish up with finding invalid data in a CSV file.
Graded: Qwiklabs Assessment: Debugging Python Scripts : 25% Weightage
- Key Concepts
- Understand what slowness is and utilize tools to identify the bottleneck causing the issue
- Utilize tools like iotop and iftop to identify exhausted resources
- Understand the different computer components and how they can contribute to slowness
- Understand how to write efficient code, and utilize the use of data structures and loops to help your code run efficiently
- Utilize concurrency, caching services, and threads to improve the execution of your code
In this module, you’ll learn about what factors can cause a machine or program to act slowly. You’ll dive into ways of addressing slowness by identifying the bottleneck that might be causing the slowness. You’ll learn about tools to identify which resources are being exhausted, including iotop, iftop, and activity monitor in MacOS. Next, you’ll learn how computers use resources, and understand the differences between CPU, RAM, and Cache in order to help you find the possible causes for slowness in our machines or scripts.
Next up, you’ll learn how to write efficient code, then explore profilers to help you identify where your code is spending most of its time. Next, you’ll dive into data structures and understand which ones are right for you to use. These include lists, tuples, dictionaries, sets, and expensive loops. Then, you’ll dive into complex slowness problems and how utilizing concurrency and adding a caching service can improve the execution of your code. Finally, you’ll understand how using threads can make the execution of your code much quicker.
Graded: Qwiklabs Assessment: Performance Tuning in Python Scripts : 25% Weightage
- Key Concepts
- Understand the difference between system and application crashes
- Utilize skills in debugging and log reading to identify these crashes
- Understand the different types of code crashes and be able to address invalid memory errors
- Utilize techniques, like printf debugging, to troubleshoot and resolve unhandled errors and exceptions
- Understand how communication and documentation during an outage or error is critical
- Understand what a postmortem is and what should be included in one
In this module, you’ll get introduced to the age old question, “Why has my program crashed?” You’ll learn how to troubleshoot system crashes and application crashes, what tools you can be used to help identify the cause of the crash, and what log files to look at in order to find what might have gone wrong. Next, you’ll dive into investigating why code crashes, and what you can do to prevent that from happening. Then, you’ll explore what happens when an unhandled error occurs and throws an exception. You’ll learn about the printf debugging technique, which will help you identify these errors and exceptions. Finally, you’ll explore the concept of handling crashes and incidents at a much larger scale.
You’ll delve into a scenario where a large eCommerce site will throw an error 20% of the time. Once that issue has been fixed, you’ll understand the importance of communication and documentation during these incidents, and how writing a post mortem can prevent issues from happening again.
Graded: Qwiklabs Assessment: Fixing Errors in Python Scripts : 25% Weightage
- Key Concepts
- Understand how to manage disk space, avoid network saturation, and manage memory leaks
- Utilize their techniques to manage their time correctly by prioritizing tasks and estimating how long tasks will take
- Understand the importance of communicating expectations of completing tasks, fixes, and bugs
- Understand how to deal with complex problems by breaking them down
- Utilize proactive approaches like continuous integration or having a test environment
- Utilize best practices when planning for the future
In this module, you’ll learn how to manage your applications. You’ll dive into some common issues that may cause your application to crash. You’ll also understand what memory leaks are, and how to troubleshoot and prevent them. Up next, you’ll run down managing disk space; you’ll see some scenarios of how this happens and how to identify what process or application is taking up all your disk space. Then, you'll learn what network saturation is, how it can be caused, and some useful tools and techniques to solve a network saturation problem.
Next, we’ll shift from managing applications to managing your time. You’ll get tips on how to prioritize tasks, estimate how long a particular task will take before finishing, and communicate expectations when dealing with important tasks. The final lesson delves into how to deal with hard and complex problems by breaking it down into small, digestible chunks while keeping your eyes on a clear goal. You’ll learn that using proactive approaches, like continuous integration, can help you with future issues that might come up. You’ll also explore how to plan for future resource usage by making good use of monitoring.
Graded: Qwiklabs Assessment: Debugging and Solving Software Problems : 25% Weightage
Warm Regards,
Piyush Sambhi
Email: piyush.sambhi07@icloud.com
Git URL: https://github.com/sambhipiyush