Kadane's Algorithm is a dynamic programming approach used to find the maximum sum subarray from a given array. This problem is fundamental in the field of computer science and has applications in various domains that require optimization, analysis of financial data, signal processing, and more. To understand Kadane's Algorithm, let's start with the basics and build up to the algorithm itself using first principles.

### First Principles Approach

1. Subarray: A subarray is a contiguous part of an array. For example, in the array [1, -2, 3, 4], [1, -2], [3, 4], and [1, -2, 3, 4] are subarrays, but [1, 3] is not because it is not contiguous.

2. Maximum Sum Subarray Problem: The problem is to find the subarray within an array that has the highest sum. Consider the array [-2, 1, -3, 4, -1, 2, 1, -5, 4]. The subarray [4, -1, 2, 1] has the maximum sum of 6.

3. Brute Force Approach: A naive method to solve this problem is to consider all possible subarrays, calculate their sums, and keep track of the maximum sum encountered. However, this approach has a time complexity of O(n^2), which becomes inefficient for large arrays.

4. Dynamic Programming: This is a method for solving complex problems by breaking them down into simpler subproblems. It is applicable where the problem can be divided into stages, with a decision required at each stage that will lead to a sequence of decisions.

Kadane's Algorithm leverages dynamic programming principles efficiently to solve the maximum sum subarray problem in linear time, O(n), where n is the number of elements in the array. The key insight of the algorithm is to look at every position in the array and decide whether to start a new subarray or continue the existing subarray.

#### Steps:

1. Initialization: Start with two variables, max_current and max_global. Initially, both are set to the first element of the array. Here, max_current tracks the maximum sum of the subarray ending at the current position, and max_global tracks the maximum sum found so far.

2. Iteration: Iterate through the array starting from the second element. For each element, update max_current as the maximum of the current element and the sum of max_current and the current element. This decision checks whether adding the current element to the existing subarray is beneficial or starting a new subarray with the current element is better.

3. Update max_global: After updating max_current, check if max_current is greater than max_global. If yes, update max_global with the value of max_current. This step ensures that max_global always holds the maximum sum encountered so far.

4. Result: After iterating through the entire array, max_global will contain the maximum sum of any subarray within the given array.

#### Pseudocode:

function kadaneAlgorithm(array):
if array is empty:
return 0

max_current = max_global = array[0]

for each element in array from the second element to the last:
max_current = max(element, max_current + element)
if max_current > max_global:
max_global = max_current

return max_global


The algorithm works based on the idea that any maximum sum subarray ending at position i is either the maximum sum subarray ending at position i-1 plus the element at i or just the element at i itself. This approach efficiently reduces the problem to a series of local optimizations that lead to a global optimum, embodying the essence of dynamic programming.