• Corpus ID: 86710992

Clean Architecture: A Craftsman's Guide to Software Structure and Design

  title={Clean Architecture: A Craftsman's Guide to Software Structure and Design},
  author={Robert C. Martin},
Components You may find it strange that we would create a component—in this example, UService—that contains nothing but an interface. Such a component contains no executable code! It turns out, however, that this is a very common, and necessary, tactic when using statically typed languages like Java and C#. These abstract components are very stable and, therefore, are ideal targets for less stable components to depend on. When using dynamically typed languages like Ruby and Python, these… 

What is in a Name? An Analysis of Associations Among Java Packaging and Artifact Names

The results of this research indicate that, on average, class names and inheritance (supper class names) tend to be considered as a packaging strategy, rather than textual factors (artifact names) associated with the package structure.

Did JHotDraw respect the Law of Good Style? - An exploratory deep dive into the nature of false positives of bad code smells

The realization that not only general design ideas but also specific design ideas have an influence on whether a potential smell is a true positive turns the problem of false positives from a scientific problem to a engineering problem.

ViMoTest: a low code approach to specify ViewModel-based tests with a projectional DSL using JetBrains MPS

It is concluded that a low code approach using a projectional DSL to specify automated tests based on ViewModels could have several benefits compared to similar approaches.

Mind Overflow: A Process Proposal for Decomposing Monolithic Applications in Microservices

The case study showed promising results, indicating that Mind Overflow is feasible to break down monolithic to a microservice-based architecture, including reducing cyclomatic complexity and producing highly cohesive microservices.

Investigating Whether Clean Code Helps Developers in Understanding a New Project

This study researches two methods that could improve the understandability of the code for newcomers: Refactoring the code to adhere to Clean Code guidelines and providing an introductory document.

A preliminary evaluation on the relationship among architectural and test smells

By mining 798 releases of 40 open-source Java systems, the correlation between class-level architectural and test smells is studied, finding that Eager Test and Assertion Roulette smells often occur in conjunction with Cyclically-dependent Modularization, Deficient Encapsulation, and InsufficientEncapsulation architectural smells.

Determining Microservice Boundaries: A Case Study Using Static and Dynamic Software Analysis

A systematic approach for refactoring systems to microservice architectures that uses static analysis to determine the system's structure and dynamic analysis to understand its actual behavior is described.

Choosing a Global Architecture for Mobile Applications

An overview of the current situation and choices and a vision of using a mix-and-match approach with the following goals: provide an extendable approach suitable for small and large projects, use minimal integration into the platform, and sidestep traps and erroneous implementations are given.

Refactoring the Whitby Intelligent Tutoring System for Clean Architecture

The architectures of two iterations of Whitby are evaluated with respect to the motivations behind the refactor: clean architecture enabling code reuse and extensibility and third-party libraries that can be reused in other applications.

Mask-Mediator-Wrapper: A revised mediator-wrapper architecture for heterogeneous data source integration

This paper identifies certain realistic and concrete scenarios where the mediator-wrapper architecture underperforms and these issues are addressed with the extension of the architecture via the mask component type.