Design Patterns and Object-Oriented Design
Kanban emphasizes the importance of solid object-oriented design though the implementation of design patterns. Object-oriented design helps architects to map a software system’s required behavior to structures or objects within that system and to define how those objects will communicate. This promotes greater flexibility and maintainability of the software. Software architects familiar with design patterns can easily identify recurring problems and their corresponding solutions. Object-oriented design and programming enables the reuse of those solutions and avoids the duplication of effort by system architects and developers.
Code reuse saves time and effort. Achieving a high level of reuse is perhaps the most difficult goal to accomplish in developing a software system. The reuse of code and designs is considered a major benefit of using object-oriented technologies. To leverage the reuse possibilities that object-oriented programming provides requires forethought and planning. Kanban has developed extensive code libraries that can be leveraged as a solution for future projects. Leveraging existing code both increases quality and decreases cost. Communication is fundamental to code reuse and is the responsibility of the software architects.
Avoiding Unnecessary Complexity
Doing “the simplest thing that could possibly work” is central to Extreme Programming (XP), and it is a concept that Kanban holds in high regard. Due to the range of components available in a software development process, it is tempting for some to over-engineer solutions, accepting greater complexity for capabilities irrelevant to the business requirements. Complexity adds to cost throughout the software lifecycle. We take the time to thoroughly analyze the requirements so as not to over-simplify or over-complicate the solution.
Performance and Scalability
It is of the utmost importance for an enterprise application to meet performance and load expectations and exhibit sufficient scalability (the potential for an application to support increased load, given appropriate hardware). Scalability is an important consideration during the architecture phase of software applications. Kanban ensures that its applications are designed to operate efficiently in a clustered environment. Kanban’s solid understanding of J2EE and .NET infrastructure is essential to meeting both performance and scalability requirements.
Maintenance and Extensibility
Maintenance is the most expensive phase of the software development lifecycle. Because of this, Kanban pays particular attention to maintainability when designing an enterprise software solution. A custom software application is likely to be a key part of an organization’s software mix for years, and must be able to accommodate new business needs without the need for a redesign. Maintainability and extensibility depend largely on a well-planned and well-executed architecture. Kanban engineers design solutions to ensure that each component of the application has a clear responsibility, and that maintenance is not hindered by tightly-coupled components.
Testing and Quality Assurance
At Kanban, testing is not an afterthought; it is an integral part of the software development cycle. Testing is done proactively; test cases are created based on requirements and iteratively updated during the development cycle. The Kanban QA team is not solely responsible for the quality of the software product; unit tests are created by our developers, often even before the code is written. Unit tests are written from a developer’s perspective. Unit tests ensure that a particular method of a class successfully performs a set of specific tasks. Each unit test confirms that a method produces the expected output when given a known input. Kanban combines functional tests and unit tests to ensure a comprehensive process that greatly improves the quality of the software product.