## Algorithmic Complexity Amir Kirsh & Adam Segoli Schubert ___  © All rights reserved ## Why this talk? ## Why this jpg) ## Algorithmic Complexity Performance is the name of the game ## Algorithmic Complexity It’s actually about something BIGGER than just performance ## Algorithmic Complexity What's BIGGER than performance? ## Algorithmic Complexity What's BIGGER than just performance? ## Scalability # Computational Complexity Computational Complexity or simply Complexity of an algorithm is the amount

## Amortized $ \mathcal{O}(1) $ Complexity Andreas Weis CppCon 2024 $$ \blacksquare f\in\mathcal{O}(g)\iff\exists C>0.\exists x_{0}>0.\forall x>x_{0}:|f(x)|\leq C\cdot|g(x)| $$ Child's What is amortized complexity? The Design and Analysis of Computer Algorithms  What is amortized complexity?  # What is amortized complexity? # AMORTIZED COMPUTATIONAL COMPLEXITY $ ^{*} $ ROBEY EMORE

# Quantifying Accidental Complexity An empirical look at teaching and using C++ Herb Sutter ## Why complexity matters We’re “paying taxes” all the time Productivity Correctness and quality Tooling catalog, classify, and count ## Fred Brooks: Complexity ## Essential complexity Inherent in the problem, present in any solution ## Accidental complexity PUSH Artifact of a specific solution design today's complex thing, to explain how it maps to the simpler thing. Quantifying Accidental Complexity: An empirical look at teaching and using C++ Herb Sutter "Definite first/last use" (see

sapien, sed malesuada diam lacus eget erat. ## Local phase Validate small neighborhoods with high-complexity algorithms. Describe neighborhood interactions coarsely in small tables. ## Global phase Collate Collate the small tables into a big table of interactions. Validate the interactions with low-complexity algorithms. Indirect caller's interface fits many functions Function interface fits a specific

parts of the software task, those concerned with fashioning abstract conceptual structures of great complexity. I suggest: • Using rapid prototyping as part of a planned iteration in establishing software parts of the software task, those concerned with fashioning abstract conceptual structures of great complexity. I suggest: • Exploiting the mass market to avoid constructing what can be bought. • Using rapid properties of this irreducible essence of modern software systems: complexity, conformity, changeability, and invisibility.” ## Complexity • Software entities are more complex for their size than perhaps

Semantically based interoperability guarantees ## • Efficient • No penalty for generality • Complexity guarantees at the interface level ## • Natural • C/C++ machine model and programming paradigm generality • Complexity guarantees at the interface level ## • Natural • C/C++ machine model and programming paradigm • Support for built-in data types ## The design principles: ## Complexity and the Big-O Big-O Notation • Complexity refers to the runtime cost of an algorithm • Big-O notation expresses the relative complexity of an algorithm |Type|Notation|Runtime Cost| |---|---|---| |Constant|O(1)|Independent

predictability and consistent behavior (once pattern is recognized) Enables system scaling (in size and complexity) ## Symmetry (def): Agreement in dimensions due to proportion and arrangement  probing of your components and subsystems will identify changes to lower system complexity • Does each step express clear purpose? • If yes, is more obvious for enforcing step semantics obvious for where a desired action should be placed • Are the steps guaranteed to occur? • If yes, complexity is reduced (edge cases are removed) • Can a step be “empty” (e.g., “do nothing” or “default” behavior

} ## COMPLEXITY LEVEL I : EVERYTHING IN THE SAME THREAD  The arrow of time ## COMPLEXITY LEVEL I: EVERYTHING more worker threads to this ## COMPLEXITY LEVEL 2 : MULTIPLE WORKER THREADS  ## COMPLEXITY LEVEL 2 : MULTIPLE WORKER THREADS before callback ## COMPLEXITY LEVEL 2 : MULTIPLE WORKER THREADS  Python callback handler ## COMPLEXITY LEVEL 2 : MULTIPLE

sort algorithm. /// /// Time complexity is `O(n + k)` on average, where `n` is the number of elements, /// `k` is the number of buckets used in process. /// /// Space complexity is `O(n + k)`, as it sorts 34;), ] ); } ## 基数排序 /// Sorts the elements of `arr` in-place using radix sort. /// Time complexity is `O((n + b) * logb(k))`, where `n` is the number of elements, /// `b` is the base (the radix) When `n` and `b` are roughly the same magnitude, this algorithm runs in linear time. /// /// Space complexity is `O(n + b)`. pub fn radix_sort(arr: &mut [u64]) { let max: use = match arr.iter().max()

priorities, or technical considerations. Story Points – Unit of measurement to estimate relative complexity of user stories Velocity – The amount of work the team estimates it can deliver in a sprint Development representatives, analyze each user story and use measures known as story points to estimate the relative complexity of developing that capability. The development team assigns points to each story following discussion support frequent collaboration.| |One or a few contractor(s) or teams can perform development.|Complexity|Many contractors are required to develop program elements.| |Program can leverage test infrastructure