Sensor-Based Monitoring and Management of Software Artifacts

Abstract

Nowadays software engineers rely on continuous integration (CI) tools together with version con- trol systems (Git, SVN, Mercurial) to build and detect eventual conflicts between concurrent changes by different developers. The tools currently being used can run test suits on the project and even run some static (e.g. code style verification) and dynamic analysis (e.g. code coverage) through additional plugins. In this scenario we have a centralized server that runs a continuous integration tool, for instance Jenkins with a set of plugins for some extra analyses. The flow em- ployed is such that developers make commits, the server pulls them, builds the piece of software, employs the analysis defined and notify the team of the build status. This approach used to mon- itor and manage code artifacts is monolithic and too coarse-grained to be scalable. In addition, developers cannot register interest in specific artifacts that affect them. CodeAware, an ecosystem inspired by sensor networks consisting of monitors and actuators, aimed at improving code quality and team productivity, will be the research topic. The ecosystem is composed of: artifacts that can go from a variable to an entire application; probes which can be static, dynamic or meta, that are agents attached to a certain artifact; coor- dinators which are active agents that listen on probes and manage actors; actors which are agents that take actions like alerts, code updates, log an issue among others on behalf of a coordinator; dashboards which are passive agents with UI for monitoring probe input and actor behaviour for its subscribers. To support the input of these elements in the system a domain specific language (DSL) is used. CodeAware approach is fine-grained, distributed (each developer defines probes, coordinators and actors) and flexible/targeted (the probes are attached with artifacts). In order to build CodeWare some challenges should be addressed such as: ensure performance; control impact on sensed artifacts; deal with code evolution; ensure scalability. With this system we want to emphasise efficient and proactive prevention over fault localisa- tion and fixing.