DEV Community: Faith Mueni Kilonzi

Think Like a Tester: A Developer’s Ultimate Guide to Software Testing and Writing Quality Code

Faith Mueni Kilonzi — Fri, 07 Mar 2025 07:15:41 +0000

For so long, software development has been like throwing code over a wall and hoping someone catches it. The "throw it over the wall" approach with developers on one side writing code, and QA on the other testing, often led to delays and frustration as bugs were discovered late in the process, making them time-consuming and expensive to fix. A better approach is long overdue.

Modern methodologies like Agile and DevOps promote collaboration. Agile methodologies like Scrum and Kanban are based on short sprints, continuous feedback, and collaboration among all stakeholders including developers and QA testers.

Continuous integration, a core principle of agile methodology, means that testing is no longer an afterthought or a final hurdle - it's proactively built into your development workflow through healthy collaboration. Shift-left testing, the tech buzzword of the day (whether you love it or hate it), encourages developers to write unit tests (tests for individual code units) and integration tests (tests for how different code modules work together) as they code. This proactive approach allows them to spot bugs early, when they're easier and cheaper to fix. A Capgemini study revealed that a staggering 70% of defects are discovered during testing, stressing the value of earlier developer involvement.

[Industry experts underscore the benefits of this integrated approach. Lisa Crispin, a leading agile testing expert, emphasizes the importance of breaking down silos between developers and testers: "In the agile world, testers and developers work together as a team with a shared goal: delivering high-quality software that meets the needs of the business." Jez Humble, co-author of the DevOps Handbook, highlights the synergy: "Developers who understand testing can write better code, and testers who understand development can write better tests." Developers are now more often involved in testing other than unit and integration tests, such as API, security, and performance testing, which we will cover in more detail in this post.]

Categories of software testing

Developers are increasingly taking an active role in software testing, and for good reason. Early involvement in the testing process provides early bug detection, improved code quality and reliability, faster iteration and feedback loops, and more frequent releases.

At a high level, you can divide software types into three main categories:

Tests that assess technical application quality
Performance and usability testing
Security testing

Essential tests for developers to know

Functional testing

Unit testing ensures your code works, but functional testing takes it a step further. It focuses on the user experience, ensuring a smooth and bug-free journey. It catches usability issues and integration problems early in the development process. For example, a user might struggle to log in due to a typo in the URL configurations connecting the front-end and back-end. This issue could be missed by unit tests but caught by comprehensive functional testing.

Functional testing ensures that an application works as intended according to the specified user requirements. It involves testing the application with valid and invalid input to verify the expected output.

Mastering functional testing empowers you as a developer to build better applications more efficiently, with a clear focus on the end user. By simulating how users interact with the code, developers can identify and fix issues early. As an agile developer, you should execute exploratory and automated functional testing on new features to catch bugs early. Tools like Selenium and Cypress enable you to write automated functional tests across browsers and devices.

Unit testing

As a developer, you strive to write clean, reliable code. Unit testing is your secret weapon in this quest. It involves meticulously checking individual code blocks such as functions, modules, and classes, to ensure they function flawlessly.

Why are unit tests so crucial? Well, they ensure that every line of code gets covered, leaving no stone unturned in the quest for comprehensive code coverage. Unit tests detect issues early, improve code reliability, and give developers more confidence when refactoring code.

Mastering unit testing empowers you as a developer to take ownership of code quality from the start. Frameworks like Jest, JUnit, xUnit, MSTest, and pytest simplify writing unit tests. Sauce Labs offers frameworks and utilities to simplify unit testing across languages and frameworks.

Integration testing

Integration testing is the assessment of how multiple units or modules of code function as a group. The primary purpose of unit testing is to ensure that newly developed code units can integrate effectively into an existing codebase without introducing compatibility or dependency issues.

As such, integration testing is another type of test that usually happens quite early in the software development life cycle – usually right after unit testing is complete. Integration tests can also be automated in most cases. Some test automation frameworks that support unit testing, such as Jest, also enable integration tests. In addition, so-called end-to-end testing frameworks, which are designed to support a broad set of testing types, also usually facilitate integration tests. Selenium is an example of this type of framework.

Performance testing

As a developer, it is not enough to code and release software products, you have to care about their stability. At any point in the SDLC, you need to ask yourself a couple of questions: Does your app render quickly and flawlessly every time on every device and operating system? Are your page transitions fast and smooth? Are your users satisfied with the pace of their transactions on your site? Can it handle an increase in user traffic? That is the essence of performance testing.

Performance testing measures how an application handles load, stress, and volume. It evaluates an application’s responsiveness, speed, and stability under various conditions. As a developer, you need to master how to implement performance tests to identify bottlenecks and ensure optimal performance under peak loads. Services like Sauce Labs allow you to execute automated performance tests at scale across geographic locations.

Accessibility testing

Accessibility testing is a type of testing that ensures that an application works well for different types of users, including those who face challenges that don't apply to a majority of users. For example, accessibility tests can validate whether an application performs well for users with hearing or visual impairments.

Accessibility tests can be performed using a combination of automated and manual testing techniques. Some accessibility features, such as tools within an app that allow users to increase the size of fonts, can be assessed automatically, but collecting manual feedback from users with particular accessibility needs helps provide additional context and detect accessibility issues that automated tests may overlook.

Visual/UI testing

Visual/UI testing is a testing method designed to detect issues related to the appearance and layout of an application. For example, if an image inside a Web application appears in a distorted fashion on devices with small screens, visual/UI tests should surface the issue.

Thus, it's important to understand that visual/UI tests don't typically collect feedback from actual users on whether they like an application's visual interface. This is instead a type of automated test that validates whether the application UI renders in the way developers intended. Determining whether users actually like the UI or not is a separate issue (which brings us to usability testing, discussed below).

Visual regression testing

As a developer, you are constantly making code updates that may affect the user interface (UI) of the software you are building. Code updates may bring about UI and visual bugs in the software that end up affecting the usability of applications and websites. This is why visual regression testing, part of visual testing, is crucial for developers to master. It ensures that any updates to the system, software, or code do not impact the product's user interface or usability.

User interface (UI) and visual bugs in software products are often disregarded due to the focus on functional testing. Visual regression testing works in such a way that every time a code change occurs, it looks for any unexpected visual changes or visual “regression” defects by taking snapshots of the user interface and comparing them from one commit instance to another. For example, Sauce Labs Visual Testing (formerly Screener.io) can be integrated into your pipeline for continuous integration to automate visual testing by continuously recording and running tests in the cloud. Sauce Labs Visual employs screenshots and DOM snapshots to detect visual bugs on app pages and ensure a platform-independent UI. Read on and learn how to implement visual testing using Sauce Labs.

End-to-end testing

End-to-end testing is a term that refers to all of the types of software tests that teams would normally perform during the software development life cycle. It's not a specific type of test as much as it's a catch-all phrase that encompasses all of the testing requirements of modern applications.
The goal of end-to-end testing is to ensure that all aspects of an application meet all requirements to which they are subject. If you perform each type of software test described above, you're performing end-to-end testing.

Security Testing

We are already experiencing too many cybersecurity software breaches in various sectors for developers not to care about security testing. It is your responsibility as a developer to ensure that your software solution addresses known security vulnerabilities because, after all, your software’s security is only as good as your last test.

Security testing detects vulnerabilities that could compromise an application. Security testing methods such as penetration testing, vulnerability scanning, and fuzzing help detect weaknesses in applications that could be exploited. Developers should conduct regular security testing, especially for applications handling sensitive data. Open-source tools like OWASP ZAP and commercial services offer support for automated security testing. Additionally, Sauce Labs integrates with leading security testing tools to help developers remediate issues and build more robust software.

There are other multiple types of security tests, such as:

Software Composition Analysis (SCA), which assesses applications for insecure dependencies or components.
Static Application Security Testing (SAST), which scans source code for problems like injection vulnerabilities.
Dynamic Application Security Testing (DAST), which simulates malicious interactions with running applications to detect potential vulnerabilities.

Because each type of security test reveals different types of risks, teams typically perform multiple types of security testing.

Additional testing practices for developers

As developers take a more active role in testing, several additional best practices such as code reviews, static code analysis, and automated testing should be incorporated into the development workflow. These practices complement the essential tests discussed previously and further help to catch issues early, improve code quality, and streamline the development process.

Code Reviews

Code reviews are a collaborative process where developers examine each other’s code to identify potential bugs, performance issues, adherence to best practices, security vulnerabilities, and opportunities for improvement before the code is merged into the main branch. It's important for developers to regularly review each other's code and give constructive feedback. This helps in creating high-quality software that's easy to maintain and also helps in sharing knowledge among team members. Code reviews play a crucial role in the software development process, making sure that developers work together and maintain the integrity of the code. This results in robust, reliable, and efficient software being released.

Static Code Analysis

SonarQube, PMD, and Bandit are static code analysis tools that help developers spot errors in their source code without running it. These tools identify style violations, performance errors, or vulnerabilities, assisting developers in dealing with such issues at the early stages of development. Static code analysis improves and secures developers' code while facilitating development, making applications or software more reliable and maintainable.

Automated Testing: Continuous Integration Continuous Deployment(CD/CD)

Manual testing is tiresome. As a developer, speed is your superpower, and test automation is critical. This is why CI/CD should be your greatest friend, as it automates testing processes and ensures thorough testing for each code update. Leveraging CI/CD tools such as Jenkins, Travis CI, and GitLab CI helps to speed the process, whereas Sauce Labs supports comprehensive testing across several environments and browsers. This test automation detects errors earlier, speeds product releases, and reduces regression risks. Embracing CI/CD and employing these test automation tools allows developers to streamline workflows, focus on high-quality code, and deliver software rapidly and consistently.

Testing in the Software Development Life Cycle (SDLC)

You can perform most types of software tests on an ad hoc basis, or via processes that are not linked to other aspects of software development. But in most cases, software testing is faster and more efficient when it is integrated into the software development life cycle (SDLC) such that tests happen routinely and (to the extent possible) automatically.

For example, running unit tests as part of the SDLC means that whenever developers write a new unit of code, a unit testing routine automatically begins. Likewise, performance testing as part of the SDLC would mean that as soon as a new application release candidate is compiled and deployed into a testing environment, automated performance tests occur.

Manual vs. Automated Testing

As noted above, most types of software tests can be performed automatically using frameworks that let engineers define what they want to test using code, then execute tests automatically.

In most cases, automated testing saves substantial amounts of time. It also keeps tests more consistent because tests that are based on the same code will be identical.

However, as we saw above, certain types of tests, such as usability tests, are difficult to perform automatically. And even when you can automate tests, you may not have the development resources available to write testing code for every single test that you want to run. For these reasons, even highly efficient teams should expect to perform a certain amount of tests manually.

Automated vs. Comprehensive Testing

Automated testing is also sometimes compared to comprehensive testing, but this comparison can be a bit misleading. Comprehensive testing refers to all types of tests that must take place to ensure an application works as required for all users – and also that it's secure.
Thus, comprehensive testing is not the opposite of automated testing. On the contrary, automated tests are usually an important component of comprehensive testing, since running every type of test is easier when you automate them. That said, just because you automate some or most tests doesn't mean you're performing comprehensive testing. You need to be covering every key type of test for your testing routine to be comprehensive.

Continuous Testing
Continuous testing is another buzzword you may encounter in discussions about types of software tests. Continuous testing means running tests routinely and automatically as part of the software development process. It implies that tests are well integrated into the SDLC – often with the help of cloud-based test infrastructure that makes it possible to run a wide variety of tests on demand – and its goal is to ensure that tests are as efficient and comprehensive as possible.
That said, continuous testing doesn't mean that testing happens on a literally continuous basis. There may be moments when no testing is taking place if you're waiting for new code to test. But as long as you test regularly, and provided that each step in the SDLC triggers relevant types of tests, you can say you're performing continuous testing.

Quality software is thoroughly vetted software

The world of software development is all about teamwork these days, and that includes testing too!

Testing doesn’t have to be overwhelming, boring, or entirely manual. When you embrace testing as a shared responsibility between QA, software developer engineers in test (SDETs), and developers it helps empower all parties involved to quickly deliver high-quality and reliable software. Getting familiar with comprehensive automation tools like Sauce Labs, and becoming comfortable with all the right essential tests – including unit integration, functional, performance, and security testing – is critical to achieving continuous integration.

Desperation in Interviews Will Never Land You a Job!

Faith Mueni Kilonzi — Thu, 07 Sep 2023 06:14:25 +0000

Hey there, job seekers! We get it—interviews can be super nerve-wracking. But here’s the deal: desperation during an interview is a big no-no. Trust me; I’ve been on both sides of the table, and I’ve learned that recruiters and HR managers can spot desperation from a mile away. And guess what? They might use it against you during salary negotiations.

REASONS TO LEARN PYTHON WITH DJANGO IN 2022

Faith Mueni Kilonzi — Fri, 14 Jan 2022 09:31:39 +0000

It is that time of the year – the beginning- where everyone is giving their opinion on the booming tech stack. This year, I have resolved to focus on Python as my core language and sticking with that. When it comes to Python for web development, Django and Flask are the two go-to web frameworks. While Flask is an equally good framework, I am going with Django. I will be sharing my journey and the insights gotten thereof.
This piece will discuss some of the golden reasons why you should start learning Django in 2022.

The video version of this tutorial is available on Youtube

YouTube:

1 Open-Source Python Web Framework

Django is a high-level open-source python framework that has neem escalating demands in the market ever since with assured growth.

2 Increasing Demand

The demand for Django professional is increasing every single day with high demanding salary and career launches.
The average salary of a Django developer is $120,000 per year.

3 New Interview Opportunities

Getting a job is nice but getting an interview might change your life. This is because an interview offers you the opportunity to promote yourself and negotiate. Django Framework is used by most big tech companies, including Instagram, National Geographic, Mozilla, Spotify, Pinterest, Disqus, Bitbucket, Eventbrite, and Prezi.

4 High Job Market Share

The market share and demand for Django developers is high, with over 70,000 vacancies and a market share of over 28% since 2021.

5 Industry Opportunities

Learning Django will provide you a huge advantage in the industry, opening you new doors and allowing you to develop a variety of skills. This ensures that Django professionals will have plenty of career opportunities.

YouTube:

Conclusion

With so many new languages, frameworks, and technologies being released on a regular basis, deciding which stack to use is a personal choice. The above discussion, on the other hand, is a guidance for individuals who are unsure about their path in Python, Django, and even Flask.

API Performance Monitoring for product managers

Faith Mueni Kilonzi — Sun, 28 Mar 2021 09:47:36 +0000

APIs have become very useful in most SaaS products. There is still a gap, however, when it comes to understanding how they work; particularly for the purpose of monitoring them. Some developers do not realize that APIs fail. And when they fail, users usually blame the application’s poor performance on the product owners rather than the third-party APIs used in the app. The developers also waste a lot of time debugging their app trying to “solve” what was just but a network issue.

This post was first published here: https://sweetcode.io/api-performance-monitoring-an-introduction/

The reverse of a number using python

Faith Mueni Kilonzi — Thu, 15 Oct 2020 07:51:18 +0000

Given a number, reverse its digits and print the new number.
For example:
Input : num = 8972
Output: 2798

There are a couple of ways to solve this:

1. Reverse Number using String slicing

We convert the given number to string using str()
Reverse it using string slicing
Convert the reversed string to int and return the int.

def reverseNumber(n):
    reversed_number = int(str(n)[::-1])
    return reversed_number

2. Reverse Number using While Loop

Using a while loop, iterate through the list of the digits from the last one and append the digits into a new number.

def reverseNumber(n):
    reversed_number = 0
    while(n!=0):
        r=int(n%10)
        reversed_number = reversed_number*10 + r
        n=int(n/10)                    
    return reversed_number

Sorting Algorithms in Python

Faith Mueni Kilonzi — Sun, 15 Mar 2020 17:31:00 +0000

What is Sorting

Sorting - ordering a list of data items in a pre-defined sequence
Sorting algorithms are a set of instructions that take an array or list as an input and arrange the items into a particular order.
Sorts are most commonly in numerical or a form of alphabetical (called lexicographical) order, and can be in ascending (A-Z, 0-9) or descending (Z-A, 9-0) order.
There are many types of sorting algorithms: quick sort, bubble sort, balloon sort, radix sort, merge
sort, quick sort, insertion sort, selection sort, etc. Not one can be considered the fastest because each algorithm is designed for a particular data structure and data set. It would depend on the data set that you would want to sort.
In this post, I will focus on the 5 most commonly used sorting algorithms in Python.

1. Insertion Sort

In Insertion sort, you compare the key element with the previous elements. If the previous elements are greater than the key element, then you move the previous element to the next position.
Usually, start from index 1 of the input array.

def insertion_sort(arr):
    '''
    insertion sort function that takes an array to be sorted as an input.
    With your key element at the index 1 of the input array,
    traverse the array comparing the key element with the previous elements.
    If the previous element is greater than the key element,
    then move the previous element to the next position
    '''
    l = len(arr)
    i=1 #key element index
    while i<l:
        key_element=arr[i] 
        j=i-1 #previous element index
        while j>=0 and arr[j]>key_element:
             # Move elements of arr[0..i-1], that are 
        # greater than key, to one position ahead 
        # of their current position 
            arr[j+1] = arr[j]
            j=j-1  

        arr[j+1]=key_element 
        i=i+1

    return arr

Properties of Insertion Sort

Space Complexity: O(1)

Time Complexity: O(n), O(n* n), O(n* n) for Best, Average, Worst cases respectively.

Sorting In Place: Yes

Stable: Yes

2. Selection Sort

Selection Sort selects the current smallest element and swaps it into place.

Here's how it works:

Find the smallest element in the array and swap it with the first element. >2. Find the second smallest element and swap with the second element in the array.

Find the third smallest element and swap wit with the third element in the array.

Repeat the process of finding the next smallest element and swapping it into the correct position until the entire array is sorted.

def selection_sort(alist):
    for i in range(0, len(alist) - 1):
        smallest = i
        for j in range(i + 1, len(alist)):
            if alist[j] < alist[smallest]:
                smallest = j
        alist[i], alist[smallest] = alist[smallest], alist[i]

    return alist

Selection sort Properties

Space Complexity: O(n)

Time Complexity: O(n2)

Sorting in Place: Yes

Stable: No

3. Bubble Sort

The algorithm traverses a list and compares adjacent values, swapping them if they are not in the correct order.

def bubble_sort(alist):
    n=len(alist)
    for i in range(n):
        for j in range(i):
            if alist[j]>alist[j+1]:
                temp = alist[j]
                alist[j] = alist[j+1]
                alist[j+1] = temp

    return alist

Pros

It is one of the easiest sorting algorithms to understand and code from scratch.
From technical perspective, bubble sort is reasonable for sorting small-sized arrays or specially when executing sort algorithms on computers with remarkably limited memory resources.

Cons

Because the time complexity is Ο(n2), it is not suitable for large set of data.
bubble sort is very slow compared to other sorting algorithms like quicksort.

Selection sort Properties

Space complexity: O(1)

Best case performance: O(n)

Average case performance: O(n*n)

Worst case performance: O(n*n)

Stable: Yes

4. Quick Sort

Quick sort uses divide and conquer approach. It divides the list in smaller 'partitions' using 'pivot'. The values which are smaller than the pivot are arranged in the left partition and greater values are arranged in the right partition. Each partition is recursively sorted using quick sort.
The pivot can be the first, the last, the medium or any random element on the array.

The steps involved in Quick Sort are:

Choose an element to serve as a pivot.

Partitioning: Sort the array in such a manner that all elements less than the pivot are to the left, and all elements greater than the pivot are to the right.

Call Quicksort recursively, taking into account the previous pivot to properly subdivide the left and right arrays.

def quicksort(z):
    if(len(z)>1):        
        piv=int(len(z)/2)
        val=z[piv] 
        lft=[i for i in z if i<val]
        mid=[i for i in z if i==val]
        rgt=[i for i in z if i>val]

        res=quicksort(lft)+mid+quicksort(rgt)
        return res
    else:
        return z

Quick sort Properties

Space complexity: O(n)

Not stable

Time Complexity: Best case – nlog(n)

part 1

part 2

5. Merge Sort

Merge sort is a sorting algorithm based on divide and conquer programming approach. It keeps on dividing the list into smaller sub-list until all sub-list has only 1 element. And then it merges them in a sorted way until all sub-lists are consumed.

def merge(left,right,compare):
    result = [] 
    i,j = 0,0
    while (i < len(left) and j < len(right)):
        if compare(left[i],right[j]):
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    while (i < len(left)):
        result.append(left[i])
        i += 1
    while (j < len(right)):
        result.append(right[j])
        j += 1
    return result



def merge_sort(arr, compare = lambda x, y: x < y):
     #Used lambda function to sort array in both(increasing and decresing) order.
     #By default it sorts array in increasing order
    if len(arr) < 2:
        return arr[:]
    else:
        middle = len(arr) // 2
        left = merge_sort(arr[:middle], compare)
        right = merge_sort(arr[middle:], compare)
        return merge(left, right, compare)

Merge sort Properties

Space Complexity: O(n)

Time Complexity: O(nlog(n)).

Stable: Yes

Complexities Summary of Sorting Algorithms

References
Image illustrations adapted from:
https://www.w3resource.com/
https://www.freecodecamp.org/
https://www.geeksforgeeks.org/

Nevertheless, Faith Kilonzi Coded

Faith Mueni Kilonzi — Sat, 07 Mar 2020 16:55:41 +0000

✨✨

Equality in Tech

I envision a tech industry where everybody is treated equally regardless of their gender. I would like to see everyone being given equal chances and paid what they are worth.
More specifically, I would like to see ZERO gender discrimination which usually comes off as:

Negative or sexist jokes being passed in the workplace
Less support for women from their senior leaders than a man who was doing the same job
Women in tech jobs are being paid less than a man doing the same job
Someone treating a women in tech as if they are not competent because of their gender
The gender biases in recruitment processes and the assumption that women are not technical enough

My expertise

I am passionate about problem-solving through implementation of high-quality software products especially back-end and web-applications using a variety of programming languages and technologies.I hold a bachelor’s degree in computer science from Ashesi University. I have experience working in academia, fin-tech, healthcare, research, technology and consultancy industries both in Kenya and Ghana.
Driven by intellectual curiosity, I combine my passion for tutoring,software development, data science and technical writing to create digital content through my online blog. I am also fascinated by community development through problem-solving to make the world a better place.

My advice

"There is a danger in letting people misname you; if you are a fire, do not answer when they call you a spark"
-Upile Chisala

Dear codess, give up the self-doubt, show up and do what you do best. It is time! Happy international Women's Day!

Time Complexities Of Python Data Structures

Faith Mueni Kilonzi — Wed, 19 Feb 2020 08:27:12 +0000

Every data structure performs various operations when implementing an algorithm. Some of the key and general operations include iterating over a collection, inserting an item at a point in the collection, deleting, updating or creating a copy of an item or the entire collection. In programming, the choice of the data structure is very important as it affects the performance of the application. This is because the operations of the data structures have different time and space complexities.

Space Complexity

Space Complexity is generally used to refer to the measure of how much space an algorithm takes. It includes both auxiliary space and space used by input.
Auxiliary Space is the extra space or temporary space used by an algorithm.
Space Complexity of an algorithm is total space taken by the algorithm with respect to the input size.

Time Complexity

Time Complexity is the the measure of how long it takes for the algorithm to compute the required operation. Time complexity is measured using the Big-O notation.
Big-O notation is a way to measure performance of an operation based on the input size,n.

Run-time Complexity Types (BIG-O Notation Types)

Constant time O(1)
An algorithm is said to have a constant time when it’s run-time not dependent on the input data(n). No matter how big your collection is, the time it takes to perform an operation is constant. This means that the algorithm/operation will always take the same amount of time regardless of the number of elements we’re working with. For example, accessing the first element of a list is always O(1) regardless of how big the list is.
Logarithmic time O(log n)
Algorithms with logarithmic time complexity reduce the input data size in each step of the operation. Usually, Binary trees and Binary search operations have O(log n ) as their time complexity.
Linear time O(n)
An algorithm is said to have a linear time complexity when the run-time is directly and linearly proportional to the size of the input data. This is the best possible time complexity when the algorithm has to examine all the items in the input data. For example:

for value in data:
print(value)

Example of such operations would be linear search hence the iteration over the list is O(n).

4. Quasilinear time(n log n)
Where each operation in the input data have a logarithm time complexity. Commonly seen in optimized sorting algorithms such as mergesort, timsort, heapsort. 
In mergesort, the input data is broken down into several sub-lists until each sublist consitsts of a single element and then the sublists are  merged into a sorted list. This gives us a time complexity of O(nlogn)

5. Quadratic time  O(n^2): 
An algorithm is said to have a quadratic time complexity when the time it takes to perform an operation is proportional to the square of the items in the collection. This occurs when the algorithm needs to perform a linear time operation for each item in the input data. Bubble sort has O(n^2) .For example, a loop within a loop:

for x in data:
for y in data:
print(x, y)


6. Exponential time O(2^n) 
An algorithm is said to have an exponential time complexity when the growth doubles with each addition to the input data set. This kind of time complexity is usually seen in brute-force algorithms. For example, the recursive Fibonacci algorithm has O(2^n) time complexity. 

7. Factorial time (n!)
An algorithm is said to have a factorial time complexity when every single permutation of a collection is computed in an operation and hence the time it takes to perform an operation is factorial of the size of the items in the collection. The Travelling Salesman Problem and the Heap’s algorithm(generating all possible permutations of n objects) have O(n!) time complexity.
Disadvantage:It is very slow.

<h5>Big-O notation Summary Graph</h5>

![Image alt text](https://www.geeksforgeeks.org/wp-content/uploads/mypic.png)


<h5>Best, Average and Worst Cases</h5>

1. Best case scenario
In the best-case analysis, we calculate lower bound on running time of an algorithm. Best-case scenario occurs when the data structures and the items in the collection along with the parameters are at their optimum state . This causes the minimum number of operations to be executed. For example, in linear search problem, the best case occurs when x(the item we are searching for) is present at the beginning of the list. The number of operations in the best case is constant (not dependent on n). So time complexity in the best case would be O(1)

2. Average case scenario 
Occurs when we define the complexity based on the uniform distribution of the values of the input. 
In average case analysis, we take all possible inputs and calculate computing time for all of the inputs. Sum all the calculated values and divide the sum by total number of inputs. We must know (or predict) distribution of cases. For the linear search problem, let us assume that all cases are uniformly distributed (including the case of x not being present in array). So we sum all the cases and divide the sum by (n+1).  

3. Worst Case Scenario
Worst case scenario could be an operation that requires finding an item that is positioned as the last item in a large-sized collection such as a list and the algorithm iterates over the collection from the very first item. For example, a linear search’s worst case occurs when x is not present in the list so the iteration compares x with all the elements.This would give us a run-time of O(n) 


<h5>Time Complexities of Python Data structures</h5>

1. List
Insert: O(n)
Get Item: O(1)
Delete Item:O(n)
Iteration: O(n)
Get Length:  O(1)

2. Dictionary
Get Item:  O(1)
Set Item:  O(1)
Delete Item:  O(1)
Iterate Over Dictionary: O(n

3. Set
Check for item in set: O(1)
Difference of set A from B: O(length of A)
Intersection of set A and B: O(minimum of the length of either A or B)
Union of set A and B: O(N) with respect to length(A) + length(B)

4. Tuples
Tuples support all operations that do not mutate the data structure (and they
have the same complexity classes).

Data Structures in Python

Faith Mueni Kilonzi — Sun, 16 Feb 2020 15:10:53 +0000

DATA STRUCTURES IN PYTHON
You can never be an efficient programmer without mastering data structures and algorithms. Problem solving in programming is impossible without the basics. Regardless of which aspect of python programming you want to focus on, you can’t ignore data, its organization and the algorithms you need to find solutions to their manipulation and data analysis.
Data structures are a way of organizing data in such a way that you can store collections of data, relate the, and perform operations on them. Data structures are derived from the term: data abstraction which is the use of data structures to solve problems by focusing on the main picture without getting lost in the details of meta-data and data access. They ease the process of problem-solving and ensure efficiency.
In other words, data structures are an actual implementation of the Abstract Data Types (ADT). This implementation requires you to have a physical view (how data collections are stored and organized) in a particular programming language’s constructs and basic data types.
There are two ways of grouping data structures in python:
(i) Built-in and User-Defined Data Structures

(ii) Primitive and Non-Primitive Data Structures

Primitive Data Structures

Integers : Used to represent numeric data, more specifically whole numbers from negative infinity to infinity, like 2,3, -100000, 10000.
Float : ‘Float’ stands for floating point number. It is used for rational numbers usually ending with decimal figure such as 1.1,2.3,9.3 etc.
String : Strings are a collection of alphabets, words or other characters. In Python, strings are created by enclosing a sequence of characters within a pair of double or single quotes. x= “Hello World”. Explore the different string operations here
Boolean : It is a built-in data type that can take the values TRUE or FALSE

Non-Primitive Data Structures

This section covers some of the primitive (and built-in) Python Data Structures.

Lists
Stores indexed elements that are changeable and can contain duplicate items.
Mutable, ordered series, traditionally of the same type of object.
Advantages: Mutable and ordered. Easy to understand. Relatively efficient memory usage.
Disadvantages: Searching is O(n).
To create a list, use square brackets:
mylist = [ ]
mylist = [1,2,3]
mylist = ['a', 'b', 'c', [1,2,3] ] # 4 elements
Tuples
Stores indexed, unchangeable elements that can have duplicate copies.
Immutable, ordered series traditionally containing different objects
Advantages: Immutable and ordered. Relatively efficient memory usage (more than lists).
Disadvantages: Searching is O(n). Hard to understand for many Python newcomers.
Dictionaries
Mutable, unordered pairs (keys and values) of objects. Keys must be hashable.
Advantages: O(1) searching for keys. Makes it easy to create trees and other hierarchical data structures. Can be used to create self-documenting code. Many problems can be described in terms of key-value pairs.
Disadvantages: Only lookup by key. Uses more memory than lists and tuples. Keys must be hashable.
Sets
A set is a collection which is unordered and unindexed. In Python sets are written with curly brackets.
Once a set is created, you cannot change its items, but you can add new items.
Advantages:Relatively efficient memory usage (more than lists).
Disadvantages: Sets are unordered, so you cannot be sure in which order the items will appear.Searching is O(n).

We will cover each of the data structures in the next tutorials. Thank you for reading!

What you need to know before you include Python in your software stack in 2020

Faith Mueni Kilonzi — Sun, 19 Jan 2020 12:53:41 +0000

It’s the year 2020 and as usual, you will see a lot of blogs and conversations around ‘top 20 programming languages to master in 2020, what a full stack software engineer needs to know in 2020… how to earn the 6-figure salary in 2020… etc., I am not bringing a different message too 😉 I am just here to share my piece of cake too. Python.
I fell in love with Python right from my introductory course to Computer Science not only because it is arguably the best language for beginners, but it’s also extremely powerful.

Why Python?

The underlying principles of the design of the python language focuses on clarity and simplicity.

Python’s rapid and robust development capabilities can be applied in projects of any size- from the start-ups to already established corporations.

The use of python saves on time and money; you can quickly build MVP, do fast iterations, implement new features when necessary, integrate with other software and build a scalable business with a varying number of team members. PS: when working with python, you just need a small but strong team size for fast and efficient collaborations.

What can you do with Python?
Some the world’s biggest corporations such as Facebook, Google, Spotify, Netflix, Instagram, IBM and Quora have placed a bet on python.

There are 3 major applications of Python in the real world: web and app development, scripting, and data science.

(i) Python for Scripting
Python has been designed with modules that help scripting basic functionalities quite easy. You can use python scripts to build email automation services, SMS features, data extraction from excel sheets, decrypting pdf files, reading and writing files, web scraping, etc.
I recently discovered a book by AL Sweigart, Automate the Boring Stuff with Python which is very good for practical scripting for both beginners and intermediate developers.

(ii) Python for Web and app development
The two most popular python frameworks, Django and Flask are quite useful when developing web and apps. Django has a more general use while Flask is mostly useful in relatively smaller projects.

(iii) Python for Data Science
Python is a very crucial language when it comes to AI development, in this case Data Science which includes machine learning, data visualization, and data analysis. Python has been supported by a number of libraries and frameworks such as TensorFlow, scikit-learn, matplotlib, seaborn, which are powered by machine learning algorithms to build smart systems. Most of the AI-powered applications such as recommender systems and business intelligence analytics have a great improvement on customer behavior and results in businesses.

In conclusion…

If you want to python to be part of your software stack in 2020, you could decide on which aspect you want to focus on either as a scripting language, web development or data science. It wouldn’t take much to focus on all the 3 too if you are up for the task 😉 Whichever path you choose, I wish you a safe ride 😊

What you need to know about OOP in Python

Faith Mueni Kilonzi — Fri, 10 Jan 2020 09:52:00 +0000

Understanding Python Classes
Python is an Object-oriented programming language. This means that everything is an object in python, with properties and methods which define the object.
A class in python, is a blueprint or a prototype for creating objects. For instance, if you want to build a house, you will first need a blueprint containing basic properties (characteristics) and methods(functionalities) of what a general house would look like. Using the class, you can now create instances (different examples) of the same house. A class is therefore an object constructor that defines the object.
For example, to create an object Student, we represent a student with properties such as name, course, age, student number, etc., and behaviors such as reading, attending class, programming, etc. Another object could be an animal whose properties include number of legs, habitat, name, type of food, etc. and functionalities such as walking, eating, living, etc.
Simply put, OOP is an approach used to model real-life entities which have data associated with them and can perform certain functions.

         Creating the class

Use a class keyword.
Class Animal(object):

The python constructor: init ()

Every python class starts with a function called init () which is used to initialize the object’s attributes by assigning to them their default values. This function has at least one argument(parameter) called self which references the object itself e.g. Animal.

class Animal:

# Initializer / constructor
def __init__ (self, name, habitat):
    self.name = name        
    self. Habitat = habitat

Instantiating Objects
To instantiate an object means to create a new, unique instance of a class. You call the class name by giving it real values to model an example of the class.
class Animal:

# Initializer / constructor

def init (self, name, habitat):

    self.name = name


    self. habitat = habitat

Instantiate the Animal object

Animal_object = Animal(“Dog”, “home”);

Access an instance attributes

print(animal_object.name)
print(animal_object.habitat)

Instance Methods
Instance methods are functions that belong to the object and are defined inside a class to get contents of an instance. They are used to perform operations with the object attributes. For example, a getName method is used to get the name of the object instantiated by the class. Like the init method, the first argument is always self.

class Animal:

# Initializer / constructor

def init(self, name, habitat):

    self.name = name


    self.habitat = habitat

instance method

def getName(self, name):

    return self.name

instance method

def description(self):

    return "my name is a {} and I live in the {}".format(self.name,   self. habitat)

Instantiate the Animal object

animal_object = Animal(“Dog”, “home”);

Calling an instance method

animal_object.getName(“Puppy”)
animal_object.description()

Save the animal.py file and run it. The output you see should be:
Puppy
My name is a dog and I live in the home.
Modify Object Properties
You can change the value of the object properties.
To change the name of the object:
animal_object.name= ‘Mikey’

this sets the name from ‘dog’ to ‘Mikey’

To delete the property attribute:

del animal_object.name