Internship_9

Career Path Insights in Tech

Overview of Career Progression

• The speaker outlines a typical career path starting with training at an institute, followed by a maximum six-month tenure at a service company before transitioning to a product company.

• Emphasizes the importance of moving to a product company for job security and higher pay; staying too long in a service company can lead to termination after six months if not transitioned.

Job Security and Salary Expectations

• Highlights that failing to secure a position in a product company will result in limited job security, with companies likely terminating employees after 6-12 months without significant contributions.

• Discusses salary expectations, noting that established companies typically offer salaries multiplied by four to six times the years of experience.

Product Company Advantages

• States that salaries at product companies can be significantly higher (10 to 20 lakh extra), suggesting potential earnings between 28 lakh and 38 lakh for three years of experience.

Addressing Common Concerns

• Addresses concerns about educational gaps or backlogs, reassuring that practical skills often outweigh academic performance when applying for jobs.

• Reiterates that having relevant skills equivalent to three or four years of experience is more critical than educational background or gaps.

Real-Life Examples

• Shares success stories of individuals who overcame age and educational barriers, such as faculty members who transitioned into tech roles later in life, demonstrating that knowledge and skill can lead to successful careers regardless of past setbacks.

Tools and Skills Required

Introduction to Tools

• The speaker introduces the topic of essential tools needed for verification domains within tech careers.

Understanding File Types and Software

• Explains various file types (e.g., .doc files associated with Microsoft Word, .ppt files for PowerPoint), emphasizing their relevance in professional settings.

Specific Tool Discussion: G

• Introduces 'G' as a tool used for handling text files (.txt, .csv), explaining its functionality alongside other software like Notepad.

Understanding GME and Its Features

Introduction to GME

• The speaker discusses the capabilities of GME, emphasizing its ease of error detection without needing to run code.

• Highlights the importance of using attractive functions in programming, comparing modern preferences for color displays over black and white.

Downloading and Installing GME

• Advises users to download GME from Google or its official website to ensure they have the latest version.

• Stresses avoiding multiple links for downloads due to potential confusion about versions.

Using GME as a Text Editor

• Describes GME as a text editor where all coding takes place, noting its lack of multi-line comment functionality.

• Explains how single-line comments work in languages that do not support multi-line comments.

Efficient Coding Techniques

Commenting Code Efficiently

• Introduces keyboard shortcuts (Control + Slash) for commenting out lines quickly in GME.

• Discusses bulk editing features that allow rapid commenting on multiple lines, saving significant time compared to manual methods.

Importance of Shortcuts

• Emphasizes the efficiency gained through shortcuts in coding, allowing quick edits even with large amounts of code.

• Reiterates that mastering these shortcuts will lead users to prefer using GME for coding tasks due to its built-in functions.

Problem Solving with Chrome Jobs

Understanding Run Times

• Introduces a problem statement involving chrome jobs where input leads to output after a specified run time.

Time Management Challenge

• Presents a scenario where 24 runs need completion within 24 hours before a deadline, highlighting urgency and planning needs.

• Engages participants by asking them how many runs can be completed within the given timeframe, reinforcing time management skills.

Can You Complete 23 Runs in One Day?

Feasibility of Completing Runs

• The speaker questions whether it's possible to complete 23 runs in one day, asserting that while 24 is impossible, 23 can be achieved.

• A discussion follows on the number of people who believe they can finish a run within an hour, suggesting that completing 20 runs in a day is feasible due to time management.

Time Management Challenges

• The speaker emphasizes the difficulty of adhering to strict schedules, noting potential delays such as traffic or personal commitments that could hinder timely completion of tasks.

• Real-life scenarios are presented where unexpected events (like traffic jams) could disrupt planned activities and lead to missed deadlines.

Human Limitations

• The speaker discusses human limitations regarding wakefulness and productivity, arguing that realistically only about 10 to 15 runs can be completed due to breaks and distractions throughout the day.

• It’s highlighted that attempting to complete all tasks without considering human factors will likely result in failure.

Understanding Job Execution with Limited Resources

Resource Allocation Issues

• The speaker uses an analogy involving licenses for jobs, explaining that having multiple jobs cannot be executed simultaneously if limited by resources (licenses).

Parallel Execution Concept

• A solution is proposed through parallel execution using multiple systems connected to a centralized system. This allows for more efficient job handling despite resource constraints.

Automation Solutions: Chrome Jobs

Scheduling Tasks Automatically

• The concept of using "chrome jobs" or scheduled tasks is introduced as a way to automate job execution at specific times without manual intervention.

Benefits of Automation

• Setting up chrome jobs requires minimal effort (2–5 minutes), allowing for automated task completion even when the user's laptop is turned off or not actively running.

Reliability of Scheduled Jobs

• Once scheduled, chrome jobs ensure tasks are executed reliably regardless of user activity or device status, highlighting their effectiveness as a scheduling tool.

Understanding Task Scheduling in Windows and Linux

Overview of Task Scheduling

• The speaker introduces the concept of task scheduling in Windows, explaining it as a feature that allows jobs or tasks to run automatically at specified intervals.

• In Windows, users can create basic tasks through a user-friendly interface, selecting triggers such as daily, weekly, monthly, or specific events like system startup.

Configuring Scheduled Tasks

• Users can specify how often a task should run (e.g., daily at certain times), including options for running scripts like PL or Python every hour.

• The speaker emphasizes flexibility in scheduling tasks based on user needs—whether it's running multiple times a day or just once.

Cron Jobs in Linux

• Transitioning to Linux, the speaker discusses cron jobs and their configuration using five fields representing time specifications (day of the week, month of the year).

• Each field allows users to define when tasks should execute; for example, specifying particular days or months for execution.

Customizing Execution Frequency

• The speaker explains various scheduling options: hourly executions versus daily ones and how users can choose specific days for task execution.

• Examples are provided to illustrate different scenarios where tasks might need to be scheduled differently based on business requirements.

Practical Applications of Scheduling

• The discussion includes practical applications such as monitoring business metrics (profit/loss reports), which may require regular updates throughout the month.

• Emphasizes that scheduling frequency depends on specific needs—daily observations versus weekly summaries depending on context.

Conclusion and Future Topics

• The session concludes with an introduction to other tools and concepts related to task automation across platforms like Windows and Linux.

• A brief mention is made about repository tools used by companies like Intel and AMD for managing development processes.

Understanding Code Collaboration and Conflict Resolution

The Importance of Basic Functions in Programming

• Emphasizes the necessity of basic functionalities (addition, subtraction, multiplication, division) for effective programming and calculator development. Without these functions, a programmer cannot create a functional tool.

Conceptualizing Conflict Between Programmers

• Introduces the idea of two programmers (A and B) as adversaries, questioning how their relationship affects code collaboration. This sets the stage for discussing potential conflicts in a team environment.

Internal Conflicts and Code Manipulation

• Describes how A and B's animosity could lead to sabotage within their code submissions. A may delete critical lines from the codebase out of spite, impacting functionality.

• Illustrates that even minor deletions can cause significant issues in code execution. Highlights the unpredictability of collaborative coding when personal feelings interfere.

Consequences of Sabotage in Team Environments

• Discusses real-world implications where one programmer’s actions can disrupt an entire project due to personal conflicts. Raises questions about accountability and teamwork dynamics.

• Suggests that withholding code submission is not a viable solution; all changes must be shared for collective progress on projects like calculators.

Addressing Team Dynamics and Accountability

• Explores how unresolved conflicts can lead to detrimental behaviors among team members, emphasizing the need for balance in professional relationships to ensure productivity.

• Proposes that implementing undo functionalities could help mitigate sabotage but acknowledges limitations in addressing deeper interpersonal issues within teams.

Utilizing Repository Tools for Collaboration

• Advocates for using repository tools as essential resources in collaborative environments to track changes made by each team member effectively.

• Explains how repository tools log every change made by programmers, including timestamps and specific modifications, fostering transparency and accountability among team members.

Enhancing Transparency Through Version Control

• Details how version control systems allow teams to see who made what changes at any given time, reducing opportunities for malicious behavior or misunderstandings regarding code alterations.

• Concludes with the assertion that such systems eliminate scope for conflict-driven sabotage since all actions are recorded transparently, promoting a healthier work environment where accountability prevails.

Understanding Git and Its Importance in Project Management

The Role of Git in Code Management

• Git is a crucial tool for tracking changes in code, where even minor modifications (like a missing dot or letter) can be identified. It helps maintain the integrity of the project.

• When starting a new project at a company, employees often need to access various files. Instead of asking for them directly, they can use Git to retrieve the entire project code efficiently.

Cloning Repositories

• To obtain the complete project code, one must execute a command provided by their manager, typically git clone <repository-link>. This command downloads all necessary files to the local system.

• Running this single command allows users to have immediate access to the entire codebase without needing individual file requests.

Collaboration Through Git

• After cloning the repository, developers may need to make changes (e.g., adding an adder function). Once completed, they must push these changes back to the server using git push.

• Other team members can then pull these updates into their local systems with git pull, ensuring everyone has access to the latest version of the code.

Workflow Dynamics

• The process involves multiple developers working on different parts of a project simultaneously. Each developer pushes their contributions to a shared server.

• This collaborative approach ensures that all changes are integrated smoothly and that each team member's work is reflected in everyone's local copies of the project.

Code Sharing and Version Control in Companies

Understanding Basic Commands for Code Management

• The initial steps in version control involve cloning a repository. After making changes, the next step is to commit those changes to the server using the command "push."

• In a college setting, code sharing can occur through various methods such as WhatsApp, email, or other messaging platforms.

• However, in a professional environment, sharing code via informal channels like WhatsApp is not acceptable; instead, tools like Git or Perforce are used for proper code management.

Tools Used in Professional Environments

• Different companies utilize specific tools for version control: Intel may use Git while AMD might prefer Perforce (P4).

• The basic commands of version control include cloning repositories and understanding how to push and pull changes effectively.

Visualizing Changes with Version Control Systems

• A visual representation of changes made to code can be accessed through tools that show modifications over time, including who made the changes and when.

• Users can see detailed information about additions or deletions within the codebase along with timestamps indicating when these changes occurred.

Tracking Contributions Over Time

• Information regarding contributions to specific files over extended periods (e.g., 25 years) can be retrieved from version control systems like Bitbucket.

Introduction to Project Management Tools

• Jira is introduced as a project management tool used for tracking issues and managing tasks within a company. It helps identify problems in design and ensures quality assurance throughout development processes.

Understanding Professional Responsibilities in Design Corrections

The Importance of Correcting Mistakes

• Discusses the scenario where a designer makes an error (e.g., using "a + b" instead of "a - b") and emphasizes that it is crucial to identify such mistakes.

• Highlights that while one can edit or correct changes, it is not the responsibility of others to submit corrections on behalf of the designer.

• Stresses that only the designer should handle submissions, reinforcing accountability for their work.

Handling Errors Professionally

• Explains how to address errors: if a mistake is found, one should inform the designer rather than making corrections themselves.

• Questions whether informal communication methods (like WhatsApp or email) are appropriate for reporting mistakes, suggesting they may not be professional.

Utilizing Project Management Tools

• Introduces Jira as a tool commonly used in companies for tracking issues and filing tickets related to design errors.

• Describes the process of filing a ticket in Jira, including writing a subject line, description, and attaching relevant images or outputs.

Ticket Filing Process

• Outlines necessary details when filing a ticket: subject, description, project name, and assignment to the responsible designer (e.g., Raju).

• Emphasizes that once a ticket is filed with all required information, it will be assigned a unique number for tracking purposes.

Reporting Failures During Meetings

• Advises on how to report failures during static meetings by referencing the ticket number associated with any issues encountered.

• Concludes that after reporting through proper channels like Jira, it becomes easier to manage responsibilities without confusion.

The Role of Unexpected Events: A Story About Monkeys

Anecdote Involving Monkeys and Bomb Detection

• Shares an intriguing story about monkeys preventing bomb explosions at a temple by alerting authorities about hidden bombs.

Lessons from Unforeseen Circumstances

• Illustrates how unexpected events can lead to significant outcomes; even minor actions (like those from animals) can have major implications in crisis situations.

Conclusion on Accountability and Communication

• Reinforces that just as unexpected heroes can emerge in critical moments (like monkeys saving lives), professionals must also take responsibility seriously when addressing errors.

Understanding Jira for Issue Tracking

Overview of Incident Reporting

• The speaker discusses various incidents, emphasizing the importance of clarity in reporting issues. They mention that multiple miracles can happen daily, hinting at the unpredictability of incidents.

Introduction to Jira

• A reference is made to a movie about incidents, leading into a discussion on Jira as a tool for tracking issues. The speaker highlights how users can retrieve specific results using unique identifiers (e.g., "26791").

Key Components of an Issue Report

• The speaker outlines essential elements required when creating an issue report in Jira:

• Summary/Subject: Clearly state the issue type (document, code, Excel).

• Issue Type: Specify whether it’s a problem in documentation or coding.

• Reporter: By default, the user will be listed as the reporter.

Detailed Reporting Process

• Important aspects of filling out an issue report include:

• Component Affected: Identify which component is impacted (analog or digital).

• Attachments: Include images or proof related to the issue.

• Description: Provide detailed information about the problem and potential solutions.

Prioritization and Assignment

• The process involves determining priority levels (P1, P2, P3), where critical issues need immediate attention while less urgent ones can wait.

• Users are encouraged to identify who should be assigned to resolve the issue rather than relying solely on managerial assignment.

Final Steps and Communication

• After submitting an issue report:

• Users receive a unique J number for tracking purposes.

• It’s important to communicate this number to managers when discussing filed bugs or complaints.

Conclusion and Next Steps

• The session concludes with plans for future discussions regarding class schedules and further training on using Jira effectively.