🧵Programming Languages and Techniques I Unit 1 – Intro to Programming & Software Dev

Key Concepts and Terminology

• Programming involves writing instructions for computers to execute specific tasks and solve problems
• Syntax refers to the rules and structure of a programming language that must be followed for code to be valid
• Algorithms are step-by-step procedures for solving problems or accomplishing tasks (sorting, searching)
• Variables store and manipulate data within a program
  • Variables have a name, data type, and value
  • Variables can be reassigned throughout the program's execution
• Functions are reusable blocks of code that perform specific tasks and can accept input parameters and return values
• Object-oriented programming (OOP) organizes code into objects, which are instances of classes that encapsulate data and behavior
• Debugging is the process of identifying and fixing errors or bugs in code
  • Common debugging techniques include using print statements, breakpoints, and debugging tools

Programming Fundamentals

• Programming languages have different levels of abstraction (low-level, high-level) that affect their readability and performance
• Compiled languages (C++, Java) are converted directly into machine code, while interpreted languages (Python, JavaScript) are executed line by line
• Comments are used to document and explain code, making it more readable and maintainable
  • Single-line comments (// in C++, Java; # in Python)
  • Multi-line comments (/* */ in C++, Java; ''' ''' in Python)
• Indentation and formatting conventions improve code readability and organization
• Pseudocode is a high-level, informal description of an algorithm or program logic, written in a human-readable format
• Flowcharts visually represent the flow and logic of a program using symbols and arrows
• Integrated Development Environments (IDEs) provide tools for writing, debugging, and executing code (Visual Studio, Eclipse, PyCharm)

Basic Data Types and Variables

• Primitive data types are the most basic data types available in a programming language
  • Integer (int): whole numbers (42, -7)
  • Floating-point (float, double): numbers with decimal points (3.14, -0.5)
  • Boolean (bool): true or false values
  • Character (char): single characters ('a', '7', '$')
• Composite data types are built using primitive data types
  • String: a sequence of characters ("Hello, world!")
  • Array: a fixed-size collection of elements of the same data type ([1, 2, 3], ['a', 'b', 'c'])
  • List: a dynamic-size collection of elements (Python: [1, 'a', True])
• Variables are declared using a specific syntax that includes the data type and name (int age;, String name;)
• Constants are variables whose values cannot be changed after initialization, often denoted by uppercase names (const double PI = 3.14159;)
• Type conversion (casting) allows converting one data type to another (int to float, char to int)

Control Structures and Logic

• Sequential execution runs code line by line in the order it appears
• Conditional statements (if, else if, else) execute different code blocks based on Boolean conditions
  • Comparison operators (==, !=, <, >, <=, >=) compare values and return Boolean results
  • Logical operators (&&, ||, !) combine or negate Boolean expressions
• Loops (for, while) repeat a block of code multiple times based on a condition
  • For loops iterate over a sequence (array, range of numbers) or until a condition is met
  • While loops execute as long as a condition is true
• Switch statements provide a way to test a variable against multiple possible values and execute corresponding code blocks
• Short-circuit evaluation optimizes the evaluation of Boolean expressions by stopping as soon as the result is determined
• Nested control structures (loops within loops, conditional statements within loops) allow for more complex program logic

Functions and Modularity

• Functions promote code reuse, modularity, and readability by encapsulating a specific task
• Function declarations include the return type, name, and parameter list (void printMessage(String message);)
• Function calls transfer control to the function and execute its code block
• Parameters are variables that receive values passed to a function during a function call
  • Pass-by-value: a copy of the argument is passed to the function (primitives)
  • Pass-by-reference: the memory address of the argument is passed to the function (objects, arrays)
• Return statements allow functions to send a value back to the calling code and terminate the function's execution
• Recursive functions call themselves to solve problems by breaking them down into smaller subproblems (factorial, Fibonacci sequence)
• Modular programming divides a program into smaller, independent modules (functions, classes) that can be developed and tested separately

Debugging and Problem-Solving

• Syntax errors occur when code violates the rules of the programming language and prevent compilation or interpretation
• Runtime errors occur during program execution and cause the program to crash or behave unexpectedly (division by zero, accessing an array out of bounds)
• Logic errors produce incorrect results but do not cause the program to crash (incorrect algorithm, off-by-one errors)
• Print statements can be used to output variable values and trace program execution for debugging purposes
• Breakpoints allow pausing program execution at specific lines of code to inspect variables and step through the program
• Debugging tools (debuggers, profilers) help identify and diagnose issues in code
  • Stepping (step over, step into, step out) executes code line by line
  • Watches monitor the values of specific variables or expressions
• Problem-solving strategies (break down the problem, pseudocode, test cases) help approach and solve programming challenges systematically

Introduction to Object-Oriented Programming

• Object-oriented programming (OOP) organizes code into objects that encapsulate data (attributes) and behavior (methods)
• Classes are blueprints for creating objects, defining their attributes and methods
  • Class declarations include the class name and its member variables and functions
  • Objects are instances of a class, created using the class constructor
• Encapsulation hides the internal details of an object and provides a public interface for interaction
  • Access modifiers (public, private, protected) control the visibility and accessibility of class members
• Inheritance allows classes to inherit attributes and methods from a parent class, promoting code reuse and hierarchical relationships
  • Subclasses (derived classes) inherit from a superclass (base class) and can add or override members
  • Polymorphism allows objects of different classes to be treated as objects of a common parent class
• Abstraction focuses on essential features and behavior, hiding unnecessary details
  • Abstract classes cannot be instantiated and may contain abstract methods
  • Interfaces define a contract of methods that implementing classes must adhere to
• Composition (has-a relationship) allows objects to contain other objects as member variables, modeling complex relationships between classes

Practical Applications and Projects

• Text-based games (adventure games, quizzes) involve user interaction, string manipulation, and control structures
• Data analysis and visualization projects use libraries (matplotlib, pandas) to process and display data
• Web scraping projects extract data from websites using libraries (BeautifulSoup, Scrapy) and can be used for data mining or analysis
• Automation scripts can be used to automate repetitive tasks (file management, data entry) using libraries (os, subprocess)
• GUI applications (calculators, note-taking apps) use libraries (Tkinter, PyQt) to create graphical user interfaces
• Mobile app development (Android with Java, iOS with Swift) involves using mobile SDKs and frameworks to create applications for smartphones and tablets
• Game development (Unity with C#, Pygame with Python) involves using game engines and libraries to create interactive games
• Contributing to open-source projects allows collaborating with other developers, improving existing software, and gaining practical experience