Architecting for Application Requirements: Understanding SLAs and Resiliency
Explore application requirements and architect infrastructure and applications to meet them. Learn about SLAs, resiliency, caching, and best practices for robust system design.
Designing Energy Efficient Storage Architectures for Environmental Sustainability
Discover how to design environmentally conscious storage architectures, optimize cloud storage efficiency, and measure code's carbon footprint through practical tools and implementation strategies.
How to Use Dependency Injection to Write Maintainable Software
Explore dependency injection techniques in C++ to create decoupled, easily refactored, and testable components. Learn to manage data and behavior dependencies for simplified, maintainable software.
Breaking Dependencies: The Path to High-Quality Software
Discover strategies to reduce software dependencies, enhancing code quality and maintainability. Learn practical techniques for creating robust, flexible, and scalable C++ applications.
Properties of Unit Tests
Explore key properties of unit tests and their impact on design goals, enhancing your understanding of effective test-driven development in C++.
Abstraction: The True Superpower of C++ - Meeting C++ 2022
Explore abstraction in C++: its meaning, mechanisms, and benefits. Learn to create clearer, more maintainable code using C++'s powerful abstraction facilities.
Overview of Platform Architecture: Handling Complex Integrations
Explore a robust architecture handling complex integrations, overcoming engineering challenges to achieve stability and maintainability.
Domain-Driven Design Principles and Patterns - CodeCamp
Explore principles and patterns for crafting elegant object systems in software development through Domain Driven Design concepts.
Writing Clean Scientific Software
Learn strategies for writing readable, reusable, and maintainable scientific code. Master techniques for creating concise functions, restructuring complex code, and effective commenting.
Socially Responsible Software Development - Teaching Software Design Systematically
Explore socially responsible software development and its importance in education. Learn strategies for creating curricula that emphasize software as a message to future developers.
Design is Testability - Understanding Software Testing Through Design Principles
Explore software design's impact on testability, linking design concepts to testing strategies for effective automated testing in continuous integration systems.
Hiding Your Implementation Details in C++ - Challenges and Best Practices
Explore challenges and best practices for hiding implementation details in C++. Learn to write more elegant, robust, and maintainable code by mastering encapsulation and decoupling techniques.
Graph Algorithms and Data Structures in C++20 - Lecture
Explore modern, composable graph algorithms and data structures in C++20. Learn to leverage concepts for systematic organization and discover an emerging proposal for a standard graph library.
Breaking Dependencies - C++ Type Erasure Implementation Details - Lecture
Explore C++ Type Erasure implementation details, from basic wrappers to advanced optimization techniques. Learn to reduce coupling and enhance software design with this powerful pattern.
Back to Basics: Object-Oriented Programming in C++ - CppCon 2022
Explore object-oriented programming in C++, covering encapsulation, inheritance, and polymorphism. Learn best practices, design considerations, and common pitfalls for novice to intermediate developers.
Value Oriented Programming Part V - Return of the Values
Explore value semantics in C++ programming, focusing on improved code readability, correctness, and maintainability. Learn techniques for value-oriented design and implementation.
Clean Architecture on iOS Using the VIPER Pattern
Discover practical implementation strategies for VIPER architecture in iOS development, focusing on clean code principles and real-world applications for building maintainable mobile applications.
Design Engineering: The Next Era of Software Design in the Age of AI
Explore the evolving intersection of design and programming in the AI era, examining how Design Engineering shapes software development's future through real experiences at GitHub.
Decoupling in Practice - How Good Software Engineering Can Save Your Sanity
Discover practical techniques for reducing software coupling in LabVIEW, improving build times, and creating more maintainable code through effective module dependency management and cleaner architecture design.
Modularity - From Software Design Principles to Community Organization
Explore how modularity principles extend beyond software development to reshape organizational structures, with insights into LabVIEW community's evolution and future adaptability.
An Introduction to Residuality Theory
Discover a revolutionary approach to software design through Residuality Theory, using complexity science to better manage uncertainty in business systems and interconnected components.