Yunus Emre Selcuk

A distributed execution environment for shared java objects

Abstract This paper discusses the implementation of a distributed execution environment, DJO, which supports the use of shared Java objects for parallel and distributed applications and provides the Java programmer with the illusion of a network-wide shared object space on loosely coupled distributed systems. DJO supports shared objects through an implementation of multiple reader/single writer write-invalidate DSM protocol in software, providing the shared memory abstraction at object granularity. Object distribution and sharing are implemented through the replication mechanism, transparently to application. The system enforces mutual consistency among replicas of an object. The main benefits of DJO are enhanced availability and performance due to the replicated object model and easier application design, as the underlying software takes care of distribution and memory consistency issues.

Policy enforcement upon software based on microservice architecture

Microservice is an architectural style that has recently started gaining popularity to become a new architectural phenomenon. Microservice architecture provides new opportunities to deploy scalable, language free and dynamically adjustable applications. This type of applications consist of hundreds or more of service instances. So that, management, monitoring, refactoring and testing of applications are more complex than monolithic applications. Therefore, some metrics and policies for measuring the quality of an application which is based on microservice architecture is needed. Moreover, automated tools are needed to carry out those tasks and enforce those policies. This work represents such metrics and policies. Additionally, an automated tool is implemented for automatic analysis of those metrics and policies upon software.

Role models—implementation-based approaches to using roles

A role of an entity can be defined as the set of properties that are important for an object in order to behave in a certain way, as expected by a set of other objects. A role model is a software that specifies a style of designing and implementing roles. This paper evaluates roles in the context of modeling dynamic systems by examining its foundations, surveying the recent role models available for academic use and giving implementation examples. Copyright

A role model for description of agent behavior and coordination

This paper presents a role model implementation, JAWIRO (JAva With ROles), which enhances Java with role support. After a brief introduction to role models and the capabilities of JAWIRO, the paper proceeds to a comparison of our model with another role model and a design pattern for implementing roles. These three approaches are compared on the basis of their abilities and performances. It is shown that role models are valuable tools for modeling dynamic real world entities as they provide many useful abilities without a significant performance overhead. The dynamic nature of agents represents a good domain for using roles to describe both behavior and coordination issues. The paper ends with a sample application for agents that demonstrates how characteristics of roles may be employed.

JAWIRO: Enhancing Java with roles

This paper introduces a role model named JAWIRO, which enhances Java with role support. JAWIRO implements features expected of roles, allowing a role to be acquired, dropped, transferred, suspended, resumed, etc. The main contribution of the proposed model is the provision of multiple object-level inheritance together with class-level inheritance. JAWIRO provides a better means to model dynamically evolving systems and increases the performance of method calls when compared to class-level inheritance.

An automated code smell and anti-pattern detection approach

Today, software maintenance is more expensive than development costs. As class complexity increases, it is increasingly difficult for new programmers to adapt to software projects, causing the cost of the software to go up. Therefore, its important to produce faultless and understandable code. Moreover, software projects are not developed by one person alone; even a small-scale project needs 3 or more participants working on the code at the same time. Producing well designed code during the development stage has a significant value because this process makes software projects more understandable and leads to higher code quality. Consequently, the cost of software project maintenance will decrease. Code smells and anti-patterns are symptoms of poorly designed code. The aforementioned tendencies of software projects increase the possibility of poor implementations and code imperfections. Therefore it is necessary to detect and refactor poorly designed code. This paper describes an attempt to achieve their detection.