ffsshhttiikk What I do
- Apply software engineering best practices
- Design maintainable systems
- Implement development workflows
- Ensure code quality
When to use me
When building software systems using professional practices.
Software Development Lifecycle
Requirements Engineering
class Requirement:
"""Software requirement"""
def __init__(self, id: str, title: str, description: str,
priority: str, category: str):
self.id = id
self.title = title
self.description = description
self.priority = priority # must, should, could, wont
self.category = category # functional, non-functional
self.status = "draft"
self.testable_criteria = []
def is_testable(self) -> bool:
"""Check if requirement is testable"""
return len(self.testable_criteria) > 0
class RequirementsManager:
"""Manage requirements"""
def __init__(self):
self.requirements = []
self.stakeholders = []
def add_requirement(self, requirement: Requirement):
self.requirements.append(requirement)
def get_by_priority(self, priority: str) -> List[Requirement]:
return [r for r in self.requirements if r.priority == priority]
def trace_to_code(self, requirement_id: str,
code_elements: List[str]):
"""Trace requirement to code elements"""
for req in self.requirements:
if req.id == requirement_id:
req.code_trace = code_elements
Design Patterns
Creational
class Singleton:
"""Singleton pattern"""
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
class Factory:
"""Factory pattern"""
@staticmethod
def create_product(product_type: str):
products = {
"a": ProductA,
"b": ProductB
}
return products[product_type]()
class Builder:
"""Builder pattern"""
def __init__(self):
self.product = Product()
def set_part_a(self, value):
self.product.a = value
return self
def set_part_b(self, value):
self.product.b = value
return self
def build(self):
return self.product
Structural
class Adapter:
"""Adapter pattern"""
def __init__(self, adaptee):
self.adaptee = adaptee
def request(self):
return self.adaptee.specific_request()
class Decorator:
"""Decorator pattern"""
def __init__(self, component):
self.component = component
def operation(self):
return self.component.operation()
Behavioral
class Observer:
"""Observer pattern"""
def __init__(self):
self.observers = []
def attach(self, observer):
self.observers.append(observer)
def notify(self, *args):
for observer in self.observers:
observer.update(*args)
class Strategy:
"""Strategy pattern"""
def __init__(self, algorithm):
self.algorithm = algorithm
def execute(self, data):
return self.algorithm.process(data)
Testing Strategy
class TestPyramid:
"""Testing pyramid implementation"""
@staticmethod
def unit_tests():
"""Many fast, isolated unit tests"""
pass
@staticmethod
def integration_tests():
"""Fewer integration tests"""
pass
@staticmethod
def e2e_tests():
"""Few end-to-end tests"""
pass
Code Quality
Metrics
class CodeMetrics:
"""Code quality metrics"""
@staticmethod
def cyclomatic_complexity(control_flow: dict) -> int:
"""Cyclomatic complexity"""
return control_flow.get("decisions", 0) + 1
@staticmethod
def cognitive_complexity(code: str) -> int:
"""Cognitive complexity"""
# Count nesting, jumps, etc.
return 0
@staticmethod
def maintainability_index(halstead: dict,
cyclomatic: int,
lines: int) -> float:
"""Maintainability index 0-100"""
import math
volume = halstead.get("volume", 1)
mi = 171 - 5.2 * math.log(volume) - \
0.23 * cyclomatic - 16.2 * math.log(lines)
return max(0, min(100, mi * 100 / 171))