Modularity in Programming

• Modularity involves separating a computer program into smaller, testable sub-programs before combining them into the final program.
• Modularity addresses the complexity of designing, implementing, and testing large programs by dividing them into smaller, manageable pieces.
• Dividing a program into smaller sub-programs is more effective when the sub-programs have clear logical boundaries and minimal dependencies.

Advantages of Modularity in Program Development

• Sub-programs can be reused in multiple applications needing the same functionality via libraries of objects.
• It reduces the amount of new code needed for a program.
• Team support is enhanced by letting different teams work separately on sub-programs with few dependencies.
• Smaller sub-programs are easy to understand, maintain, and debug.
• The overall program structure becomes easier to comprehend.
• Sub-programs function as "black boxes" that can be updated by team members without affecting others.
• It speeds up the completion of both the sub-programs and the entire program compared to handling it as one large task.

Class

• A class in OOP acts as a template for creating objects, defining specific data and actions.

Identifier

• An identifier names a specific entity.
• Identifiers consist of alphanumeric sequences, underscores, and should not begin with a digit.

Primitive

• A primitive is a predefined identifier (keyword) provided by a programming language.

Primitive Data Includes:

• Characters (char) represents a single character.
• Integers (int, short, long, byte) represent integers, with four primitive data types that vary in integer range.
• Floating point numbers (float, double) identify floating-point numbers, with types differing in range and precision.
• Boolean (bool) has one of two values: true or false

Method

• Methods are actions associated with an object.
• Methods provide interfaces an object depicts to the external environment, allowing classes to access and modify data properties.
• Accessor is a method to read a specific data value of an object.
• Mutator modifies a specific data value of an object.
• Constructor is a special method called when an object is instantiated, initializing its data with particular values, and it runs only once.
• Constructors use the class name and have no return type.
• Signature identifies a method, including its name, parameters, their number, and types, but not return types.
• Return Value is the value passed back to the code that called the method.
• It represents the value returned after the method's execution.

Private, Protected, Public

• 'Private', 'protected', and 'public' are access modifiers that enable encapsulation.
• Access modifiers provide the compiler with information about class data and actions accessibility.
• Private data can only be accessed by the class that defines it.
• Protected data/actions can only be accessed by the defining class and its subclasses.
• Public data or actions can be accessed by any class.

Extends

• Extends is related to the concept of inheritance and how a class can inherit from another.
• Both the Student and Professor classes inherit the data and actions of the Person class and can also define their own, unique data and actions.

Static

• Static: every class has data and actions.
• When a class object is instantiated, values are provided for the class data that can change later on without affecting other instances of the class.
• If some data or action is termed static it then belongs to the class instead of a specific instance. This means that all instance objects of the class share the same value and if that value is altered, it is altered for all the instance objects.

Primitive Data Types

• There are eight primitive data types
• Byte:
• Minimum value: -128
• Maximum value: 127
• Occupies 8 bits of memory
• Suited for saving memory in large arrays with numbers
• Short:
• Minimum value: -32,768
• Maximum value:32,767
• Occupies 16 bits
• Used for same reason as byte but wider range of numbers
• Int:
• Minimum Value: -2^31
• Maximum value: 2^31-1
• Occupies 32 bits
• The most common primitive data type to represent integer numbers
• Long:
• Minimum value: -2^63
• Maximum value: 2^63 -1
• Occupies 64 bits
• Used for numbers when the range of the int data type is not sufficient
• Float:
• Ranges from 1.4^-45 to 3.4^38
• Occupies 32 bits of memory
• Used for saving memory in big arrays of FL numbers
• Double:
• Ranges from 4.9^-324 to 1.7^308
• Occupies 64 bits of memory
• Used for representation of FL numbers
• Char:
• Minimum Value: '\u0000' - 0
• Maximum Value: '\uffff' - 65. 535
• Occupies 16 bits of memory
• It represents a Unicode Character
• Boolean
• Can take on one of 2 values: True and False
• Conditions that may have one of two outcomes
• String
• Not a primitive data type but a reference class
• Used to represent a series of chars
• Once created, it is immutable

Internationalization

• Modern programming languages enable internationalization by:
• Supporting international fonts and text
• Accommodating language and local specific needs (date, time, etc.)
• Working with different keyboard layouts, complex characters, and symbols
• Supporting various written languages using Unicode
• Enabling user language auto-detection
• Supporting global software development with localized content

Programmer Ethics

• Besides design and testing, programmers must act ethically, testing products thoroughly to minimize harm. Programmers must fulfill agreed tasks professionally without deception.
• Programmers should credit others' intellectual property and respect confidentiality and security.
• They should not include it at all if unauthorized.

Modularity involves breaking programs into smaller, testable sub-programs to manage complexity. This approach enhances code reuse, team support, and ease of maintenance. Smaller sub-programs improve understanding and debugging, streamlining program development.