\documentclass[11pt,twoside]{article}\makeatletter

\IfFileExists{xcolor.sty}%
  {\RequirePackage{xcolor}}%
  {\RequirePackage{color}}
\usepackage{colortbl}
\usepackage{wrapfig}
\usepackage{ifxetex}
\ifxetex
  \usepackage{fontspec}
  \usepackage{xunicode}
  \catcode`⃥=\active \def⃥{\textbackslash}
  \catcode`❴=\active \def❴{\{}
  \catcode`❵=\active \def❵{\}}
  \def\textJapanese{\fontspec{Noto Sans CJK JP}}
  \def\textChinese{\fontspec{Noto Sans CJK SC}}
  \def\textKorean{\fontspec{Noto Sans CJK KR}}
  \setmonofont{DejaVu Sans Mono}
  
\else
  \IfFileExists{utf8x.def}%
   {\usepackage[utf8x]{inputenc}
      \PrerenderUnicode{–}
    }%
   {\usepackage[utf8]{inputenc}}
  \usepackage[english]{babel}
  \usepackage[T1]{fontenc}
  \usepackage{float}
  \usepackage[]{ucs}
  \uc@dclc{8421}{default}{\textbackslash }
  \uc@dclc{10100}{default}{\{}
  \uc@dclc{10101}{default}{\}}
  \uc@dclc{8491}{default}{\AA{}}
  \uc@dclc{8239}{default}{\,}
  \uc@dclc{20154}{default}{ }
  \uc@dclc{10148}{default}{>}
  \def\textschwa{\rotatebox{-90}{e}}
  \def\textJapanese{}
  \def\textChinese{}
  \IfFileExists{tipa.sty}{\usepackage{tipa}}{}
\fi
\def\exampleFont{\ttfamily\small}
\DeclareTextSymbol{\textpi}{OML}{25}
\usepackage{relsize}
\RequirePackage{array}
\def\@testpach{\@chclass
 \ifnum \@lastchclass=6 \@ne \@chnum \@ne \else
  \ifnum \@lastchclass=7 5 \else
   \ifnum \@lastchclass=8 \tw@ \else
    \ifnum \@lastchclass=9 \thr@@
   \else \z@
   \ifnum \@lastchclass = 10 \else
   \edef\@nextchar{\expandafter\string\@nextchar}%
   \@chnum
   \if \@nextchar c\z@ \else
    \if \@nextchar l\@ne \else
     \if \@nextchar r\tw@ \else
   \z@ \@chclass
   \if\@nextchar |\@ne \else
    \if \@nextchar !6 \else
     \if \@nextchar @7 \else
      \if \@nextchar (8 \else
       \if \@nextchar )9 \else
  10
  \@chnum
  \if \@nextchar m\thr@@\else
   \if \@nextchar p4 \else
    \if \@nextchar b5 \else
   \z@ \@chclass \z@ \@preamerr \z@ \fi \fi \fi \fi
   \fi \fi  \fi  \fi  \fi  \fi  \fi \fi \fi \fi \fi \fi}
\gdef\arraybackslash{\let\\=\@arraycr}
\def\@textsubscript#1{{\m@th\ensuremath{_{\mbox{\fontsize\sf@size\z@#1}}}}}
\def\Panel#1#2#3#4{\multicolumn{#3}{){\columncolor{#2}}#4}{#1}}
\def\abbr{}
\def\corr{}
\def\expan{}
\def\gap{}
\def\orig{}
\def\reg{}
\def\ref{}
\def\sic{}
\def\persName{}\def\name{}
\def\placeName{}
\def\orgName{}
\def\textcal#1{{\fontspec{Lucida Calligraphy}#1}}
\def\textgothic#1{{\fontspec{Lucida Blackletter}#1}}
\def\textlarge#1{{\large #1}}
\def\textoverbar#1{\ensuremath{\overline{#1}}}
\def\textquoted#1{‘#1’}
\def\textsmall#1{{\small #1}}
\def\textsubscript#1{\@textsubscript{\selectfont#1}}
\def\textxi{\ensuremath{\xi}}
\def\titlem{\itshape}
\newenvironment{biblfree}{}{\ifvmode\par\fi }
\newenvironment{bibl}{}{}
\newenvironment{byline}{\vskip6pt\itshape\fontsize{16pt}{18pt}\selectfont}{\par }
\newenvironment{citbibl}{}{\ifvmode\par\fi }
\newenvironment{docAuthor}{\ifvmode\vskip4pt\fontsize{16pt}{18pt}\selectfont\fi\itshape}{\ifvmode\par\fi }
\newenvironment{docDate}{}{\ifvmode\par\fi }
\newenvironment{docImprint}{\vskip 6pt}{\ifvmode\par\fi }
\newenvironment{docTitle}{\vskip6pt\bfseries\fontsize{22pt}{25pt}\selectfont}{\par }
\newenvironment{msHead}{\vskip 6pt}{\par}
\newenvironment{msItem}{\vskip 6pt}{\par}
\newenvironment{rubric}{}{}
\newenvironment{titlePart}{}{\par }

\newcolumntype{L}[1]{){\raggedright\arraybackslash}p{#1}}
\newcolumntype{C}[1]{){\centering\arraybackslash}p{#1}}
\newcolumntype{R}[1]{){\raggedleft\arraybackslash}p{#1}}
\newcolumntype{P}[1]{){\arraybackslash}p{#1}}
\newcolumntype{B}[1]{){\arraybackslash}b{#1}}
\newcolumntype{M}[1]{){\arraybackslash}m{#1}}
\definecolor{label}{gray}{0.75}
\def\unusedattribute#1{\sout{\textcolor{label}{#1}}}
\DeclareRobustCommand*{\xref}{\hyper@normalise\xref@}
\def\xref@#1#2{\hyper@linkurl{#2}{#1}}
\begingroup
\catcode`\_=\active
\gdef_#1{\ensuremath{\sb{\mathrm{#1}}}}
\endgroup
\mathcode`\_=\string"8000
\catcode`\_=12\relax

\usepackage[a4paper,twoside,lmargin=1in,rmargin=1in,tmargin=1in,bmargin=1in,marginparwidth=0.75in]{geometry}
\usepackage{framed}

\definecolor{shadecolor}{gray}{0.95}
\usepackage{longtable}
\usepackage[normalem]{ulem}
\usepackage{fancyvrb}
\usepackage{fancyhdr}
\usepackage{graphicx}
\usepackage{marginnote}

\renewcommand{\@cite}[1]{#1}


\renewcommand*{\marginfont}{\itshape\footnotesize}

\def\Gin@extensions{.pdf,.png,.jpg,.mps,.tif}

  \pagestyle{fancy}

\usepackage[pdftitle={Guiding Software Developers using Automated Adaptation of Object Ensembles Plug-in By},
 pdfauthor={}]{hyperref}
\hyperbaseurl{}

	 \paperwidth210mm
	 \paperheight297mm
              
\def\@pnumwidth{1.55em}
\def\@tocrmarg {2.55em}
\def\@dotsep{4.5}
\setcounter{tocdepth}{3}
\clubpenalty=8000
\emergencystretch 3em
\hbadness=4000
\hyphenpenalty=400
\pretolerance=750
\tolerance=2000
\vbadness=4000
\widowpenalty=10000

\renewcommand\section{\@startsection {section}{1}{\z@}%
     {-1.75ex \@plus -0.5ex \@minus -.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\Large\bfseries}}
\renewcommand\subsection{\@startsection{subsection}{2}{\z@}%
     {-1.75ex\@plus -0.5ex \@minus- .2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\Large}}
\renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}%
     {-1.5ex\@plus -0.35ex \@minus -.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\large}}
\renewcommand\paragraph{\@startsection{paragraph}{4}{\z@}%
     {-1ex \@plus-0.35ex \@minus -0.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\normalsize}}
\renewcommand\subparagraph{\@startsection{subparagraph}{5}{\parindent}%
     {1.5ex \@plus1ex \@minus .2ex}%
     {-1em}%
     {\reset@font\normalsize\bfseries}}


\def\l@section#1#2{\addpenalty{\@secpenalty} \addvspace{1.0em plus 1pt}
 \@tempdima 1.5em \begingroup
 \parindent \z@ \rightskip \@pnumwidth 
 \parfillskip -\@pnumwidth 
 \bfseries \leavevmode #1\hfil \hbox to\@pnumwidth{\hss #2}\par
 \endgroup}
\def\l@subsection{\@dottedtocline{2}{1.5em}{2.3em}}
\def\l@subsubsection{\@dottedtocline{3}{3.8em}{3.2em}}
\def\l@paragraph{\@dottedtocline{4}{7.0em}{4.1em}}
\def\l@subparagraph{\@dottedtocline{5}{10em}{5em}}
\@ifundefined{c@section}{\newcounter{section}}{}
\@ifundefined{c@chapter}{\newcounter{chapter}}{}
\newif\if@mainmatter 
\@mainmattertrue
\def\chaptername{Chapter}
\def\frontmatter{%
  \pagenumbering{roman}
  \def\thechapter{\@roman\c@chapter}
  \def\theHchapter{\roman{chapter}}
  \def\thesection{\@roman\c@section}
  \def\theHsection{\roman{section}}
  \def\@chapapp{}%
}
\def\mainmatter{%
  \cleardoublepage
  \def\thechapter{\@arabic\c@chapter}
  \setcounter{chapter}{0}
  \setcounter{section}{0}
  \pagenumbering{arabic}
  \setcounter{secnumdepth}{6}
  \def\@chapapp{\chaptername}%
  \def\theHchapter{\arabic{chapter}}
  \def\thesection{\@arabic\c@section}
  \def\theHsection{\arabic{section}}
}
\def\backmatter{%
  \cleardoublepage
  \setcounter{chapter}{0}
  \setcounter{section}{0}
  \setcounter{secnumdepth}{2}
  \def\@chapapp{\appendixname}%
  \def\thechapter{\@Alph\c@chapter}
  \def\theHchapter{\Alph{chapter}}
  \appendix
}
\newenvironment{bibitemlist}[1]{%
   \list{\@biblabel{\@arabic\c@enumiv}}%
       {\settowidth\labelwidth{\@biblabel{#1}}%
        \leftmargin\labelwidth
        \advance\leftmargin\labelsep
        \@openbib@code
        \usecounter{enumiv}%
        \let\p@enumiv\@empty
        \renewcommand\theenumiv{\@arabic\c@enumiv}%
	}%
  \sloppy
  \clubpenalty4000
  \@clubpenalty \clubpenalty
  \widowpenalty4000%
  \sfcode`\.\@m}%
  {\def\@noitemerr
    {\@latex@warning{Empty `bibitemlist' environment}}%
    \endlist}

\def\tableofcontents{\section*{\contentsname}\@starttoc{toc}}
\parskip0pt
\parindent1em
\def\Panel#1#2#3#4{\multicolumn{#3}{){\columncolor{#2}}#4}{#1}}
\newenvironment{reflist}{%
  \begin{raggedright}\begin{list}{}
  {%
   \setlength{\topsep}{0pt}%
   \setlength{\rightmargin}{0.25in}%
   \setlength{\itemsep}{0pt}%
   \setlength{\itemindent}{0pt}%
   \setlength{\parskip}{0pt}%
   \setlength{\parsep}{2pt}%
   \def\makelabel##1{\itshape ##1}}%
  }
  {\end{list}\end{raggedright}}
\newenvironment{sansreflist}{%
  \begin{raggedright}\begin{list}{}
  {%
   \setlength{\topsep}{0pt}%
   \setlength{\rightmargin}{0.25in}%
   \setlength{\itemindent}{0pt}%
   \setlength{\parskip}{0pt}%
   \setlength{\itemsep}{0pt}%
   \setlength{\parsep}{2pt}%
   \def\makelabel##1{\upshape ##1}}%
  }
  {\end{list}\end{raggedright}}
\newenvironment{specHead}[2]%
 {\vspace{20pt}\hrule\vspace{10pt}%
  \phantomsection\label{#1}\markright{#2}%

  \pdfbookmark[2]{#2}{#1}%
  \hspace{-0.75in}{\bfseries\fontsize{16pt}{18pt}\selectfont#2}%
  }{}
      \def\TheFullDate{2016 2016-01-15 (revised: 27 Year 2016 15 January 2016)}
\def\TheID{\makeatother }
\def\TheDate{2016 2016-01-15}
\title{Guiding Software Developers using Automated Adaptation of Object Ensembles Plug-in By}
\author{}\makeatletter 
\makeatletter
\newcommand*{\cleartoleftpage}{%
  \clearpage
    \if@twoside
    \ifodd\c@page
      \hbox{}\newpage
      \if@twocolumn
        \hbox{}\newpage
      \fi
    \fi
  \fi
}
\makeatother
\makeatletter
\thispagestyle{empty}
\markright{\@title}\markboth{\@title}{\@author}
\renewcommand\small{\@setfontsize\small{9pt}{11pt}\abovedisplayskip 8.5\p@ plus3\p@ minus4\p@
\belowdisplayskip \abovedisplayskip
\abovedisplayshortskip \z@ plus2\p@
\belowdisplayshortskip 4\p@ plus2\p@ minus2\p@
\def\@listi{\leftmargin\leftmargini
               \topsep 2\p@ plus1\p@ minus1\p@
               \parsep 2\p@ plus\p@ minus\p@
               \itemsep 1pt}
}
\makeatother
\fvset{frame=single,numberblanklines=false,xleftmargin=5mm,xrightmargin=5mm}
\fancyhf{} 
\setlength{\headheight}{14pt}
\fancyhead[LE]{\bfseries\leftmark} 
\fancyhead[RO]{\bfseries\rightmark} 
\fancyfoot[RO]{}
\fancyfoot[CO]{\thepage}
\fancyfoot[LO]{\TheID}
\fancyfoot[LE]{}
\fancyfoot[CE]{\thepage}
\fancyfoot[RE]{\TheID}
\hypersetup{citebordercolor=0.75 0.75 0.75,linkbordercolor=0.75 0.75 0.75,urlbordercolor=0.75 0.75 0.75,bookmarksnumbered=true}
\fancypagestyle{plain}{\fancyhead{}\renewcommand{\headrulewidth}{0pt}}

\date{}
\usepackage{authblk}

\providecommand{\keywords}[1]
{
\footnotesize
  \textbf{\textit{Index terms---}} #1
}

\usepackage{graphicx,xcolor}
\definecolor{GJBlue}{HTML}{273B81}
\definecolor{GJLightBlue}{HTML}{0A9DD9}
\definecolor{GJMediumGrey}{HTML}{6D6E70}
\definecolor{GJLightGrey}{HTML}{929497} 

\renewenvironment{abstract}{%
   \setlength{\parindent}{0pt}\raggedright
   \textcolor{GJMediumGrey}{\rule{\textwidth}{2pt}}
   \vskip16pt
   \textcolor{GJBlue}{\large\bfseries\abstractname\space}
}{%   
   \vskip8pt
   \textcolor{GJMediumGrey}{\rule{\textwidth}{2pt}}
   \vskip16pt
}

\usepackage[absolute,overlay]{textpos}

\makeatother 
      \usepackage{lineno}
      \linenumbers
      
\begin{document}

             \author[1]{Md. Abir  Hosain}

             \author[2]{Ziaur  Rahman}

             \author[3]{Md. Badrul Alam  Miah}

             \author[4]{Md. Hadifur  Rahman}

             \affil[1]{  Mawlana Bhashani Science and Technology University}

\renewcommand\Authands{ and }

\date{\small \em Received: 10 December 2015 Accepted: 4 January 2016 Published: 15 January 2016}

\maketitle


\begin{abstract}
        


Software developing process has been improving day by day. The development process can be affected through different ways like changing the development environment, strategies and upcoming technologies. In order to save valuable times and to speed up the process, we can guide programmer during the development time through providing relevant recommendations. There are some strategies that suggest related code snippets and API-items to the software programmers. There are some techniques that apply general code searching approaches and some techniques that employ online based repository mining process. But it is kind of difficult tasks to guide programmers when they need specific type conversion like adapting existing interfaces from the previously used types as per their demands. One of the familiar approaches to guide developers in such a situation is to adapt collections and arrays through automated adaptation of object ensembles. But how does it help a novice developer in real time software development that is not explicitly exemplified. In this paper, we have tried to introduce a system that works as a plug-in tool incorporated with a data mining integrated environment to recommend the relevant interfaces while they look for a type conversion. We have a mined repository of respective adapter classes and related APIs from where programmers search their query and get their result using the relevant transformer classes. The system that recommends developers entitled automated objective ensembles (AOE plug-in). From the investigation that we have done, we can see that our approach works much better than some of the existing approaches.

\end{abstract}


\keywords{adaptation of object ensembles (aoe); repository mining; development process; data mining integrated environment.}

\begin{textblock*}{18cm}(1cm,1cm) % {block width} (coords) 
\textcolor{GJBlue}{\LARGE Global Journals \LaTeX\ JournalKaleidoscope\texttrademark}
\end{textblock*}

\begin{textblock*}{18cm}(1.4cm,1.5cm) % {block width} (coords) 
\textcolor{GJBlue}{\footnotesize \\ Artificial Intelligence formulated this projection for compatibility purposes from the original article published at Global Journals. However, this technology is currently in beta. \emph{Therefore, kindly ignore odd layouts, missed formulae, text, tables, or figures.}}
\end{textblock*}


\let\tabcellsep& 	 	 		 
\section[{Introduction}]{Introduction}\par
Abstract-Software developing process has been improving day by day. The development process can be affected through different ways like changing the development environment, strategies and upcoming technologies. In order to save valuable times and to speed up the process, we can guide programmer during the development time through providing relevant recommendations. There are some strategies that suggest related code snippets and API-items to the software programmers. There are some techniques that apply general code searching approaches and some techniques that employ online based repository mining process. But it is kind of difficult tasks to guide programmers when they need specific type conversion like adapting existing interfaces from the previously used types as per their demands. One of the familiar approaches to guide developers in such a situation is to adapt collections and arrays through automated adaptation of object ensembles. But how does it help a novice developer in real time software development that is not explicitly exemplified. In this paper, we have tried to introduce a system that works as a plug-in tool incorporated with a data mining integrated environment to recommend the relevant interfaces while they look for a type conversion. We have a mined repository of respective adapter classes and related APIs from where programmers search their query and get their result using the relevant transformer classes. The system that recommends developers entitled automated objective ensembles (AOE plug-in). From the investigation that we have done, we can see that our approach works much better than some of the existing approaches.\par
Keywords: adaptation of object ensembles (aoe); repository mining; development process; data mining integrated environment. oftware development process improving rapidly. A lot of guidelines are suggested which influence software development process, especially in the coding stage. Reusing previously completed software repository to enhance the development process is a common phenomenon in the field of Mining Software Repository (MSR). If developers get suggestions in e.g. API recommendations, object usage pattern, class structure or code snippets from the existing projects they might be benefited a lot what they eventually expect while coding. Some of the approaches have integrated web based code, searching in their customized tool like MAC \hyperref[b1]{(Hsu \& Lin, 2011)} and MAPO \hyperref[b2]{(Xie \& Pei, 2006)}, before mining the code source abstractions. Although MAC and MAPO are server dependent or online based, by which they are not flexible for a developer. Automated Adaptation of Object Ensembles (AOE) shows a process of adapting the collection frameworks and Arrays, but it is not clear view how to use it as a plug-in tool.\par
In software development there are different ways available to guide software developers during the development period. A programmer can use programming code in a software system easily by using an automated adaptation of object ensembles. By this process user can find out required data easily. We have used an AOE Plug-in by which a software developer can complete a code in a short time. It takes less time compared to existing approaches. The existing approaches like simply using the Integrated Development Environment (IDE) like Net Beans (NetBeans plug-in, 2015), IntellijIdea \hyperref[b4]{(Genuitec, 2015)}, and Eclipse \hyperref[b5]{(Seiffert \& Hummel, 2015)} is vulnerable to flaws and it is unable to provide us the required interfaces. In essence, it consumes developers valuable times. We have investigated between the conventional ways and our AOE plug-in approach to evaluate the efficiency of our proposed tool. The study shows that it is able to accelerate the developer's performance and facilitate less time consuming with decreasing code flaws and errors.\par
Although in MAC \hyperref[b1]{(Hsu \& Lin, 2011)}, MAPO \hyperref[b2]{(Xie \& Pei, 2006)}, AOE \hyperref[b6]{(Shahnewaz et. al, 2014)}, and many others code repository had several limitations such as server dependent searching, either database based or Internet based where data is not preprocessed according to rules of data mining so these are not friendly for a developer. In our methodology we try to show our repository plug-in as an offline repository that is filed based instead of a database and it has special source abstraction technique. Adapter classes are the key point in our approach. In AOE the result depends on the resource of the repository of adapter classes. Recently, a number of works are available to guide developers in the field of software engineering. All we have seen is that our approach is comparatively easier to handle than other existing approaches.\par
The paper is so far structured in the followings: Section II background and related works of this study. Section III shows that full design and proposed approach. The detailed results and evaluation of this paper is presented in Section IV. Section V concludes with the set of observation and future work of this research. 
\section[{II.}]{II.} 
\section[{Backgrounds and Related Works}]{Backgrounds and Related Works}\par
As the software development process can be affected by using different strategies. Researchers from parts of the world have been trying to provide ways that can speed up the development process. We can say that previously completed software repository technique to enhance the development process is a common framework in the field of mining software repository. The developers can be benefited by following the provided suggestions from various recommendations like API recommendations, object usage pattern, class structure or code snippets from the existing projects. Some of the approaches have integrated web based code, searching in their customized tool like MAC \hyperref[b1]{(Hsu \& Lin, 2011)} and MAPO \hyperref[b2]{(Xie \& Pei, 2006}) before mining the code source abstractions.\par
There are some approaches by which a software system is established by code reusing. But in our approach we use a repository of adapter classes and a tool which adapt this code. By using this AOE plug-in which integrates with the IDE, the user can search the required data type by investing less effort. There are some existing efforts such as adapting collection and array by using Automated Adaption of Object (AOE) \hyperref[b6]{(Shahnewaz et. al, 2014)}. Some approaches like Code reusing in MAPO \hyperref[b2]{(Xie \& Pei, 2006)}, better user recommendation using enhancing software development repository, Scenario Based API Recommendation System \hyperref[b5]{(Seiffert \& Hummel, 2015)}, and others are also used to speed up the software development process. As we have proposed that if there have been adapter tools \hyperref[b7]{(Kabir,Rahman \& Islam, 2015)}, which adapt the given interfaces it will be more helpful for the programmers to find the required interfaces. Mining API Usages from the Open Source Repositories (MAPO) \hyperref[b2]{(Xie \& Pei, 2006)},(NetBeans plug-in,2015), was one of the first and MAC \hyperref[b1]{(Hsu \& Lin, 2011)}, was one of the updated efforts to mine API usage pattern. Other recent works called Enhancing Software Development Process (ESDP)  {\ref (Reiss et. al, 2009)}, where the developers are highly guided by recommendations from a mined repository is also one of our referral works.\par
One of the popular concepts of test-driven reuse showed by Reiss (Reiss et. al, 2009), common test-cases issued as input for a component search engine in  {\ref (Hummel,\&Janjic,2013)}. Nevertheless, there exist some difficulties such as license problem and dependency issues. When the user changes the parameter types, then it might need an even more propagated deep adjustment of type changes. The formal and rule-based language is proposed by Kell (Kell et. al,2010), that was named Cake for automated wrapper generations. The designing used to define interface relations; transformation object structures are possible by applying these rules and strategies. We introduced that transformation should happen automatically but it is most overhead for a developer writing mapping rules, basically for an unknown object instance. It overcame Nita and Notkin (Nita \& Notkin, 2010) by providing an approach which concerned with adapting programs to alternative APIs. When the variations among the APIs are small its schema considers not-straightforward structural respect as out of scope, which is the main challenge. Another Challenge is providing transformation. The work showed by Hummel (Hummel \& Atkinson, 2010), is depending on the Identity Map Pattern from Fowler (Janjic \& Atkinson, 2012) and identifies the answer about the problems of the Gang of Four adapter pattern. The approach is integrated into another work by Hummel and Atkinson (Hummel \& Atkinson, 2010), that supplies relaxed-signature matching for primitive data types.\par
Recently there are different works available to enhance the Software Development Process (SDP). Some of them have applied many tools such as adapter generation tool \hyperref[b5]{(Seiffert \& Hummel, 2015)}. In this way a user can find the required method easily. As a result a user can save time and solve any problem easily. The software development process is an easy task for a developer.\par
In the approach we have tried to overcome the limitations of existing repository tools. We have tried to provide as an offline repository tool that are file based instead of a database that has special source abstraction. Providing recommendations using the respective Adapter Classes and the Transformer Classes are the key point in our approach.\par
In our approach we have developed a plug-in tool that is able to guide software development through suggesting interfaces by using the respective adapter classes. The tool is completely written in java and is executable as a standalone application. It can work with IDE like Net beans (NetBeans plug-in, 2015), and Eclipse \hyperref[b5]{(Seiffert \& Hummel, 2015)} as they have the software extensibility.\par
Open Source Repository (OSR) is an online software code repository. In this repository many projects problem solving codes are stored. When a programmer stays in online and gets any programming problem, then the programmer can search in this repository for required code. OSP is an Internet based repository. In many software companies, there are  In repository, there are stored a large number of programs. Many unusual code lines are staying in programs. We take the only important line for a program. By using type conversion we build up Existing Source where projects are stored without unusual code lines. Programming code is stored in Existing Sources. We extract classes of API from these projects which exist in Existing Sources.\par
Data Mining Algorithm is used to build up a mined repository of Adapter classes. When a programmer searches any classes, the required classes are shown at first. Then we will find related classes. Programmers, search their needed query in the mined repository of Adapter Classes. Then we get relevant interfaces with the help of a transformer and recommendation interfaces. The user selects the required interfaces an14014d gets the code skeleton. 
\section[{Global Journal of Computer Science and Technology}]{Global Journal of Computer Science and Technology}\par
Volume XVI Issue II Version I 29 Year 2016 ( ) adapter generation tool is one of them. To overcome mismatches on the signature level a good way is to add an adapter that controls message forwarding from one interface to the other. The adapters allow classes to work together that could not otherwise because of incompatible interfaces. It can also be familiar as a "Wrapper" which wraps the incompatible class into the adapter class, where adapter adapt any types of object, method and interface that helps in the programming fields. There exist projects available the newly integrated ability to transform arrays and collections, which can be executed for verifying the adaptation capabilities. This idea is to describe by Hummel (Hummel \& Atkinson,2010), where able to generate a random Array List and a sorted Vector instance the helper class Generator is used. When a client uses an automated adapter class that depends on the interfaces that are provided by collection frameworks then the client needs help to use any plug-in.\par
For example, when a programmer writes their code in the IDE like as Net Beans they must write the full code to reach the required result, But when they use AOE plug-in by pressing the right button, then the programmer will be guided by the several adapter classes that are shown in the Fig. \hyperref[fig_2]{2}, which is remarked by red color box is chosen. Suppose coder write ,calculate (float [], float []) then AOE plaguing suggest Euclid Distance adoptee adapt that generate in Seffert and Hummel \hyperref[b5]{(Seiffert \& Hummel, 2015)} where adapter depends on transformer that transform provided instance to require instance and vice versa. Suppose a client requires a specific data types, then its search in the adapter fields after matching needed data types client can choose any of them. By finishing the process of adaptation successfully the modified test case was executed here using the final adapter instead of the adapter directly. Nevertheless, test case executed full filly the adapter's transformation capability was verified. For example, in the test case the compute method of the selected class from org. apache. commons. math3.ml.distance package is tested. That takes as an input two vectors, showed by an array of type double each, and calculates the distance between them. The distance should be zero, if the same vector is provided as the first and second parameter such as in this example. The public double computes (double [], double []) is the interface of the compute method.\par
The array of type double was replaced with a Link List<Float> after the verification of the original test case executed successfully, where the expected name of the method was changed from compute to calculate. The test case is changed to public void double calculate (Linked List<Float>) for the require interfacing. The adapter generator overcome a parameter type and the method name mismatch, namely from Linked List<Float> on double [] and calculate in a computer.\par
Imagine a client requires one method within two parameters, but there exist more than two parameters in a similar method in the tool then adaptation process solves this complexity. In this paper, we want to The collection framework refers the way of implementing interfaces with the help of several classes that are considered as a supported plaguing tool.\par
We have seen in the approaches (Xie \& Pei, 2006), [MAPO] that they have used a code search engine to find the desired item following a search query given by a particular client. Like MAPO this paper also enhances the automated adaptation of object ensembles as a repository tool. In this approach the require source may online or offline repository that contain various kinds of tools. Eventually, the approaches are not only suggesting an adapter class, but also provide its related code implementation to reach the desired goal of a software developer. It works automatically when a client type any code during programming according to their require data types or interfaces. In order to consider the existing paper (Kabir, Rahman, \& Islam ,2015) that shows how to generate an adapter with the help of transforms that can able to solve the matching problems of complex data types. In Fig. \hyperref[fig_2]{2} shows the snapshot of the adapter generation tool. On other existing paper there have no idea about the plug-in. But in our paper, we want to use plug-in for a user.\par
A plug-in is a software component that adds a specific feature to an existing once. When an application supports plug-in, it enables customization. In our paper we want to provide an adapter plug-in by which any client can complete a task more easily than existing processes. When a client wants to find classes or interfaces, there have given some adapter class options. From these options which is chosen then it finds out the required data by using adapter plug-in. There have given a guideline for a programmer to enhance the software development process. An automated adaptation of object ensembles is a process by which any software developer can find the required data easily. There have given some comparison by which we will understand which process is better than another. 
\section[{a) Environmental setup}]{a) Environmental setup}\par
In this development process, we have used a repository of adapter classes. How much healthier this repository the development process is more easy. If our adapter class repository is enriched, a user can find the required interfaces in a short time and easily. There have given same adapter classes as shown in the Table  {\ref I}. There used an adapter generation tool. Some object oriented language is used. There it needs an adapter by which adaptation code is plagued with user. There have given an adapter generation tool such as adaptation tool.zip \hyperref[b5]{(Seiffert \& Hummel, 2015)}. 
\section[{b) Time complexity}]{b) Time complexity}\par
Time is an important thing when a program is solved. By which a program is solved quickly this process is better than other. When a programmer solves a program in IDE (Net Beans, eclipse) there have needed some times such as 40sec.    
\section[{Experimental Evaluation}]{Experimental Evaluation}\par
As a result, we understand that when the plug-in is used error rate is low. So this process is better than another. 
\section[{d) Thread of the evaluation}]{d) Thread of the evaluation}\par
Everything has a limitation. There has some limitation of evaluation. This guideline for software development process is more effective. The evaluation is observed at the same time and same experiment. Such as a. By having more AOE adapter classes in the repository a user finds more accurate data. b. A program is evaluated by the same user. c. It is a lengthy process to plug in a user in an adapter class repository. d. A user cannot find the mining data.\par
The results observed in the empirical study may not be applicable to the programming tasks other than those considered in the study, being a threat to the external validity. If the tasks mentioned out there in the study change the results may also be changed. Before we start our evaluation the team members are well trained. The receiving capacity of team members may vary. So the learning curve of these numbers may affect the results.\par
Within many problems this guideline for a programmer is more effective to develop software process. By this process a user can find any data very quickly. It will keep an important role to enhance the software development process. 
\section[{V. Conclusion}]{V. Conclusion}\par
The AOE plug-in approach is more enriched than any other Existing approaches. The approach is able to find out any required data easily and there have needed less time than any other approach. A user finds a data in adapter classes than the AOE plug-in give the required data to the client. The process which we have provided in this paper is different from any other existing process. That is able to enhance the SDP recently. This paper provided a guideline by which a user can get the required data easily and it is comfortable to use. But these data are not mined. In Future there have used data mining algorithm and find out mined data to enhance software development process. \begin{figure}[htbp]
\noindent\textbf{}\includegraphics[]{image-2.png}
\caption{\label{fig_0}Global}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{1}\includegraphics[]{image-3.png}
\caption{\label{fig_1}Figure 1 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{2}\includegraphics[]{image-4.png}
\caption{\label{fig_2}Figure 2 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{}\includegraphics[]{image-5.png}
\caption{\label{fig_3}Global}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{34}\includegraphics[]{image-6.png}
\caption{\label{fig_4}Figure 3 :Figure 4 :}\end{figure}
  \begin{figure}[htbp]
\noindent\textbf{1} \par 
\begin{longtable}{P{0.04722222222222222\textwidth}P{0.6138888888888888\textwidth}P{0.18888888888888888\textwidth}}
SL\tabcellsep Adapter Classes\tabcellsep Line of Code (LOC)\\
A\tabcellsep EuclidDistance\tabcellsep 17\\
B\tabcellsep CanberraDistance\tabcellsep 11\\
C\tabcellsep ChebyshevDistance\tabcellsep 15\\
D\tabcellsep ManhattanDistance\tabcellsep 14\\
E\tabcellsep Onew ayAnova\tabcellsep 16\end{longtable} \par
 
\caption{\label{tab_0}Table 1 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{2} \par 
\begin{longtable}{P{0.07777777777777777\textwidth}P{0.41666666666666663\textwidth}P{0.35555555555555557\textwidth}}
Task\tabcellsep IDE with AOE plug-\tabcellsep NetBeans(no of solved\\
\tabcellsep in(no of solved\tabcellsep problem)\\
\tabcellsep problem)\tabcellsep \\
T1\tabcellsep 60 sec\tabcellsep 120 sec\\
T2\tabcellsep 130 sec\tabcellsep 200 sec\\
T3\tabcellsep 150 sec\tabcellsep 310 sec\\
T4\tabcellsep 120 sec\tabcellsep 360 sec\\
T5\tabcellsep 140 sec\tabcellsep 400 sec\end{longtable} \par
 
\caption{\label{tab_1}Table 2 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{} \par 
\begin{longtable}{}
\end{longtable} \par
 
\caption{\label{tab_2}TABLE}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{3} \par 
\begin{longtable}{P{0.22666666666666666\textwidth}P{0.37777777777777777\textwidth}P{0.24555555555555553\textwidth}}
Time\tabcellsep NetBeans\tabcellsep NeatBeans\\
\tabcellsep +plug-in\tabcellsep \\
T1\tabcellsep 0\tabcellsep 0\\
T2\tabcellsep 1\tabcellsep 3\\
T3\tabcellsep 3\tabcellsep 5\\
T4\tabcellsep 4\tabcellsep 6\end{longtable} \par
 
\caption{\label{tab_3}Table 3 :}\end{figure}
 			\footnote{© 2016 Global Journals Inc. (US)} 			\footnote{© 2016 Global Journals Inc. (US)Guiding Software Developers using Automated Adaptation of Object Ensembles Plu-gin} 			\footnote{© 2016 Global Journals Inc. (US) 1} 		 		\backmatter  			 			 			  				\begin{bibitemlist}{1}
\bibitem[ Jet Brain ()]{b3}\label{b3} 	 		\textit{},  		 \url{https://www.jetbrains.com/idea/}  	 	 		\textit{Jet Brain}  		2015.  	 
\bibitem[Genuitec ()]{b4}\label{b4} 	 		\textit{},  		 			Genuitec 		.  		 \url{http://www.genuitec.com/myeclips}  		2015.  	 
\bibitem[Kabir et al. (2015)]{b7}\label{b7} 	 		\textit{},  		 			H Kabir 		,  		 			Z Rahman 		,  		 			N Islam 		.  		2015. December.  	 
\bibitem[Shahnewaz (2014)]{b6}\label{b6} 	 		\textit{A Scenerio based API recommendation system using syntax and semantics of client source code},  		 			Shahnewaz 		.  		April, 2014. Bangladesh.  		 			Department of CSE, Islamic University of Technology, OIC, Gazipur-1704 		 	 	 (Master's Thesis) 
\bibitem[Seiffert and Hummel ()]{b5}\label{b5} 	 		‘Adapting Collections and Arrays: Another Step towards the Automated Adaptation of Object Ensembles’.  		 			D Seiffert 		,  		 			O Hummel 		.  	 	 		\textit{Software Reuse for Dynamic Systems in the Cloud and Beyond},  				2015. Springer International Publishing. p. .  	 
\bibitem[Error comparison between net beans and NetBeans+plug]{b0}\label{b0} 	 	 	 		\textit{Error comparison between net beans and NetBeans+plug},  				6.  	 
\bibitem[Hsu and Lin ()]{b1}\label{b1} 	 		‘MACs: Mining API code snippets for code reuse’.  		 			S K Hsu 		,  		 			S J Lin 		.  	 	 		\textit{Expert Systems with Applications}  		2011. 38  (6)  p. .  	 
\bibitem[Xie and Pei (2006)]{b2}\label{b2} 	 		‘MAPO: Mining API usages from open source repositories’.  		 			T Xie 		,  		 			J Pei 		.  	 	 		\textit{Proceedings of the 2006 international workshop on Mining software repositories},  				 (the 2006 international workshop on Mining software repositories)  		2006. May. ACM. p. .  	 
\end{bibitemlist}
 			 		 	 
\end{document}
