Ebeledike Chukwubuikem Frank

Programing Foundations

Frank C. Ebeledike — Wed, 28 Jun 2023 10:40:03 GMT

In today's world, where technology is evolving very fast, and has several applications, programming has become an essential skill. Whether you aspire to be a software engineer, a data scientist or simply want to automate a task, understanding the fundamentals of programming is crucial.

I took a couple of Programming Foundation courses on LinkedIn Learning, under the guidance of the MASL (Microsoft ADC Student League). In this article, I will discuss some of the concepts I learned and also a short introduction to the foundations of programming: Fundamentals, Algorithms, Data Structures, Databases, Object-oriented design, APIs and Web services, Software Testing/QA.

Fundamentals

Now, what is programming? Programming is the process of converting ideas into instructions that a computer can understand and execute. It's how we get computers to perform tasks and solve problems. For us to communicate this instruction to the computer we use a programming language. Examples include Java, Python, C#, Kotlin and so on. Each of these languages has its syntax and semantics. For example, here is a program that outputs a message to the user in Python

print("Hello World")

and here is the same thing but using Java

System.out.println("Hello World")

Another important concept in programming is variable. A variable is a named memory location. Imagine how you have some colorful marbles - red, blue, and green. Now, you want to keep track of how many marbles of each color you have. So, you create three small cups, and you label them "red," "blue," and "green." These cups represent variables.

Whenever you find a red marble, you put it in the cup labeled "red." If you find a blue marble, you put it in the cup labeled "blue," and so on. The cups help you organize and remember how many marbles of each color you have. In programming, we use variables to store data temporarily. Data are of different types, for example, Name could have a value of "Esther", age could have a value of 18 and sex could have a value of 'F'. All these are of different Data Types.

Now, to write code we need an IDE (Integrated Development Environment). An IDE is an application software that has all the special tools needed to improve developer productivity to write, test, and execute software.

Algorithm

Software drives most of the technology today, and software is powered by algorithms. An algorithm is a step-by-step, unambiguous process of solving a problem or performing a particular task. An algorithm can be classified based on complexity such as space complexity and time complexity. Space complexity is the amount of memory used by the algorithm whereas time complexity is the time taken for the algorithm to complete its operation with the given input. Some common algorithms include searching algorithms, sorting algorithms, computational algorithms and collection algorithms.

Let's take a look at a search algorithm, for example, linear search. Linear search is a simple algorithm that searches for a specific element in a list by iterating through each element until it finds a match. Here is a code snippet

def linear_search(array, target):
    for index, element in enumerate(array):
        if element == target:
            return index  # Found the target element at this index
    return -1  # Target element not found in the array

my_array = [4, 2, 9, 1, 7, 5]
target_element = 7

index = linear_search(my_array, target_element)
if index != -1:
    print(f"Found {target_element} at index {index}")
else:
    print(f"{target_element} not found in the list")

Here we simply loop through each element in the array and if it's equal to the target element then we return the index. If the target element doesn’t exist in the array, we return -1. Linear search has a time complexity of O(1) for the best-case scenario and O(n) for the worst-case scenario. The space complexity is O(1) regardless of the input size.

Data Structures

In programming, we are always going to be working with different types of data. Data structure helps us organize and manipulate data efficiently. Data structures are essential in programming, as they allow for optimized algorithms and efficient problem-solving. The types of data structure are linear data structure and non-linear data structure.

In a linear data structure, the elements have a linear relationship with its adjacent element whereas in a non-linear data structure, the data elements are not arranged sequentially. Examples of linear data structures are Arrays, Linked Lists, Stacks, and Queues while non-linear data structures are Trees and Graphs. Each type has its characteristics, advantages, and specific use cases.

Let’s discuss our first data structure — arrays. An array is a data structure that allows you to store a sequence of elements, where each element is accessed using its index. Here is an example using Python

# An array of integers
numbers = [10, 20, 30, 40, 50]

# Accessing each element using it's index
for i in range(len(numbers)):
    print(f"Index: {i}, Value: {numbers[i]}")

A linked list is a collection of nodes where each node contains both the data and a reference (pointer) to the next node in the list. The last node points to None or Null indicating the end of the list. In this data structure, the elements are not stored at contiguous locations. Several operations can be performed on a linked list but here I will only focus on inserting, removing and displaying the items in a linked list.

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def is_empty(self):
        return self.head is None

    def insert(self, data):
        new_node = Node(data)
        if self.is_empty():
            self.head = new_node
        else:
            current = self.head
            while current.next is not None:
                current = current.next
            current.next = new_node

    def remove(self, data):
        if self.is_empty():
            print("Linked list is empty.")
            return

        if self.head.data == data:
            self.head = self.head.next
            return

        current = self.head
        prev = None

        while current is not None:
            if current.data == data:
                prev.next = current.next
                return
            prev = current
            current = current.next

        print(f"{data} not found in the linked list.")

    def display(self):
        if self.is_empty():
            print("Linked list is empty.")
        else:
            current = self.head
            while current is not None:
                print(current.data, end=" ")
                current = current.next
            print()

# Implementation:
my_list = LinkedList()

my_list.insert(1)
my_list.insert(2)
my_list.insert(3)
my_list.insert(4)
my_list.display()

my_list.remove(2)
my_list.display()

From the above snippet, each time we insert an item into the list, the item gets added to the end of the list.

Databases

Databases help us store, manage, and retrieve large amounts of data efficiently. A database is a structure that stores information in an organized, consistent, reliable and searchable way. There are different kinds of databases such as the Relational database, NoSQL databases, Graph databases and so on.

Let’s focus on the relational database for now. Relational databases store related data in tables with predefined schemas. They use SQL (Structured Query Language) for data manipulation and querying. Examples include MySQL, Oracle Database, PostgreSQL, and Microsoft SQL Server. In a relational database, tables are made up of rows (records) and columns (fields). Each row represents an instance of an entity and columns represent attributes of a given entity. Relational databases are designed to ensure data integrity and consistency by adhering to ACID properties. ACID stands for Atomicity, Consistency, Isolation, and Durability

Object Oriented Design (OOD)

Good software starts with a design. Before writing a single line of code the first thing to do is plan, analyze, and come up with a design. In doing so, we build software that is durable, testable and maintainable. OOD focuses on organizing and structuring code around objects, which are instances of classes that encapsulate data and behavior. In OOD, we use tools such as UML (Unified Modeling Language) to create models of our object-oriented systems. The design process is as follows

Requirements definition
Use case diagrams and user stories
Creation of conceptual model
Class diagrams
Software development

The first step in any design process is to gather your requirements. The requirements will contain what the application must do, and maybe how it should do it. In the use case diagram and user stories, the focus is on what the applications must do and how the user will interact with the application. The conceptual model represents important objects and the relationship between them. You can easily spot an object by looking out for nouns in your use case and user stories.

To create class diagrams, we will use UML. Here we must take note of the OOP principles like encapsulation, abstraction, inheritance and polymorphism. Each class diagram might have a name, attributes and behaviors.

Finally, we can start writing code. Here we build actual software. We must take note of some software design patterns, and ensure test-driven development and software development principles such as SOLID, DRY, and YAGNI.

APIs and Web Services

APIs and Web Services allow different devices to communicate over the internet.

An API (Application Programming Interface) is a set of rules, protocols, and tools that specifies how different software components should interact with each other. A web service is an API that enables communication and data exchange over the internet using standard web protocols. The two types of web services are SOAP (Simple Object Access Protocol) web services and REST (Representational State Transfer) web services.

Web services support reusability. Also since the data is exchanged using JSON or XML format, this allows for interoperability between several systems. APIs and web services provide authentication, authorization, and data encryption to ensure secure communication between different devices.

Software Testing/QA

Trying to use a software that doesn’t work can be quite frustrating, that’s why there is a need for proper testing and quality assurance (QA).

Quality assurance is a systematic process used to determine whether a product meets specifications. It includes activities such as requirement analysis, test planning, test case creation, and identifying and reporting bugs. To maintain quality it’s necessary to iterate and improve on all processes in the software development lifecycle.

Software testing is the process of evaluating a software system or its components to ensure it meets the requirements. Software testing requires a strategy. A test strategy describes how a software product will be tested so that anyone can read and understand the scope of testing clearly. There are various types of testing a QA engineer might focus on. These are

Box testing
Manual testing
UI automation testing
Integration testing
Performance testing
Security testing

When a bug is identified in software, the bug must be reported to the development team. This can be done using a bug reporting system to assign, view, triage, report and close bugs.

Conclusion

These topics are the foundations of programming and some of the concepts I learned in the LinkedIn learning courses. Having a good knowledge of each of these topics is enough to help you understand and build scalable and maintainable software. This is only a piece of the iceberg so I didn’t go in-depth to explain most concepts.

Thumbs up for coming this far. Happy learning📚.

References

https://www.linkedin.com/learning/programming-foundations-fundamentals-3

https://www.linkedin.com/learning/programming-foundations-algorithms?dApp=204528272&leis=MVL

https://www.linkedin.com/learning/programming-foundations-data-structures-2/understand-data-structures?dApp=204528272&leis=MVL

https://www.linkedin.com/learning/programming-foundations-databases-2

https://www.linkedin.com/learning/programming-foundations-object-oriented-design-3

https://www.linkedin.com/learning/programming-foundations-apis-and-web-services

https://www.linkedin.com/learning/programming-foundations-software-testing-qa

Introduction to Object Oriented Programming (OOP)

Frank C. Ebeledike — Fri, 28 Apr 2023 15:39:34 GMT

Introduction

Object Oriented Programming (OOP) is a type of Programming paradigm that centers around the concept of "objects". You can think of an object as anything. For example, if you look around you, what do you see?. Maybe a chair, a pen or a person, those are objects. An object is a basic unit of a program. It can have an identity, state, and/or behavior. An object represents real-world entities and it is an instance of a class. A class is a blueprint that defines the structure, behavior, and characteristics of an object, serving as a template for its instances.
OOP focuses on improving code readability, reusability and maintainability. The are many programing languages today that support OOP, such as Python, Java, Kotlin and so on. In this article, I will be using the Python programming language but the same concepts can be applied to other languages as well.

Below shows a code snippet for a basic class and it's corresponding object

# Define a class called person
class Person:
    pass

# Create an object of the person class
person = Person()

Principles of OOP
There are four principles of OOP, which form the basis of OOP design. They are Encapsulation, Inheritance, Polymorphism and Abstraction.

Encapsulation: This principle involves bundling data and behaviors together into a single unit (the class) and hiding the data from other external entities. This principle ensures that the data is protected from unauthorized access or modification. It does this using access modifiers. Access modifiers help to control the visibility and accessibility of the attributes and methods of an object from outside the class. Examples of access modifiers are public, protected and private.

For example, In Python, there is no strict enforcement of access modifiers like in some other programming languages. However, we can still achieve encapsulation by convention using underscores to indicate the visibility of attributes and methods.

Public: attributes and methods with no underscore prefix can be accessed from anywhere, including outside the class.

Protected: attributes and methods with a single underscore prefix can accessed from within the class and its subclasses.

Private: attributes and methods with a double underscore prefix can only be accessed from within the class.

Below shows a code snippet demonstrating encapsulation. The variable height is completely hidden and cannot be accessed outside the Person class

class Person:
  def __init__(self, name, age, height):
    self.name = name        # public attribute
    self._age = age         # protected attribute
    self.__height = height # private attribute

  def get_details(self):
    return f"{self.name} is {self._age} years old and is {self.__height}ft tall"

person = Person("Dominik", 21, 5)
print(person.name)
print(person._age)
# print(person.__height) -> We can't access this
print(person.get_details())

Inheritance: This principle allows new classes to be derived from existing classes, thereby inheriting their attributes and behaviors. A class can inherit from one or more parent classes, and the child class will have the attributes or behaviors of its parent class. A child class can also provide its specific implementation to the methods of the parent class This helps to reduce code duplication, making it easier to maintain and reuse code.

For example, Let's create a Student class that inherits from the Person class. We will give the student class an additional attribute “school”. Due to inheritance, we are able access the name and age variable and also call the get_details method even though it wasn’t declared in the Student class.

class Student(Person):
  def __init__(self, name, age, height, school):
    super().__init__(name, age, height)
    self.school = school

student = Student("Magret", 29, 6, "Federal University of Technology, Minna")
print(student.name)   # Output: Magret
print(student._age)   # Output: 29
print(student.get_details())

Polymorphism: This principle allows objects to exist in different types. For example, a person can be a student, an engineer, a doctor or a lawyer. An engineer can even be a father, a CEO and so on. In OOP, this means that you can access objects of different types through the same interface. Each type can provide its own custom implementation of this interface or simply rely on the default implementation.

To implement this in python, I will create an additional class (Engineer) that inherits from Person class and provides its own implementation of the get_details method. The object student is both a Student and a Person while the object engineer is both an Engineer and a Person. We can call the get_details method for both objects.

class Engineer(Person):
  def __init__(self, name, age, height, skills):
    super().__init__(name, age, height)
    self.skills = skills

  def get_details(self):
    return f"{super().get_details()}. {self.name} is also an Engineer with skills in {self.skills}"


student = Student("Magret", 29, 6, "Federal University of Technology, Minna")
engineer = Engineer("David", 30, 6.5, ["Java", "C++", "C#"])
print(student.get_details())
print(engineer.get_details())

Abstraction: This principle involves hiding the details of the implementation of an object and providing only essential data/information to the outside world. Imagine you want to turn on your PC, you don't need to know the inner workings of a PC or what happens behind the scene to turn on your PC, you only need to know which button to press to turn on your PC. This is the idea of abstraction in OOP and it helps to reduce complexity and make the code easier to read.

To implement this in python, let’s add an order_food method to our Student class. It takes a few steps to order food, but for a student using this program, we don’t want to bother them with the steps involved in getting this done. The student only get’s a response of whether the order was successful or not.

class Student(Person):
  def __init__(self, name, age, height, school):
    super().__init__(name, age, height)
    self.school = school

  def order_food(food_name: str):
    """
      Check if the food name is part of the MENU
      if true:
        Inform the student that the order is in progress
        prepare the food
        package the food
        deliver the food to the student's dome or hostel
      else:
        Inform the student that the food is currently not available
    """
    pass

student = Student("Magret", 29, 6, "Federal University of Technology, Minna")
student.order_food()

Benefits of OOP

OOP provides abstraction and polymorphism, which makes the code more flexible as well as easier to read and understand for other developers.
OOP allows us to break down complex software into smaller modules, making it easier to maintain. Also, changes made to a section of the code won't affect other parts of the software, reducing the risk of bugs and errors.
OOP provides Inheritance which enables us to reuse code by creating classes that can be used across different projects and applications. This means that we can avoid duplicating code which saves time and effort.

In conclusion, OOP is a programming paradigm that ensures modularity, code reuse, and abstraction. It provides a flexible and adaptable structure for building complex software systems.

Thank you for reading!