\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={Simplification of Internet Ossification through Software Defined Network Approach},
 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{2017-01-15 (revised: 15 January 2017)}
\def\TheID{\makeatother }
\def\TheDate{2017-01-15}
\title{Simplification of Internet Ossification through Software Defined Network Approach}
\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]{Gaurav  Kulkarni}

             \affil[1]{  Institute of Technology and Management Universe Vadodara}

\renewcommand\Authands{ and }

\date{\small \em Received: 10 December 2016 Accepted: 2 January 2017 Published: 15 January 2017}

\maketitle


\begin{abstract}
        


Software-Defined Networking (SDN) has received a great deal of attention from both academia and industry in recent years. Studies on SDN have brought a number of interesting technical discussions on network architecture design, along with scientific contributions. Researchers, network operators, and vendors are trying to establish new standards and provide guidelines for proper implementation and deployment of such novel approach. It is clear that many of these research efforts have been made in the southbound of the SDN architecture, while the northbound interface still needs improvements. By focusing in the SDN northbound, this paper surveys the body of knowledge and discusses the challenges for developing SDN software. We investigate the existing solutions and identify trends and challenges on programming for SDN environments. We also discuss future developments on techniques, specifications, and methodologies for programmable networks, with the orthogonal view from the Software Engineering discipline.

\end{abstract}


\keywords{software defined networking, SDN programming languages, software engineering.}

\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
he Internet architecture has become complex and hard to manage. Due to its large development and level of maturity, implementing strategies with a high degree of innovation is risky because the success of the Internet depends on the accurate operation of all of its subnets. The Internet became static and difficult to change its structure, a phenomenon known as Internet Ossification \hyperref[b0]{[1]}. The need for making networks more dynamic, robust, and able to be experimented with new ideas and protocols in realistic scenarios brought a new paradigm called Software-Defined Networking (SDN). SDN enables a new network architecture that makes possible for computer networks to be programmable \hyperref[b1]{[2]}. In its essence, SDN decouples the control plane from the forwarding plane. It enables researchers and software developers to create and deploy network applications, by abstracting the underlying infrastructure and even complex protocols present in traditional and legacy networks. Programmable networks have been the subject of active research in the past (e.g., Open Signaling \hyperref[b6]{[7]}, Active Networking \hyperref[b7]{[8]}, and Ethane \hyperref[b8]{[9]}). However, they failed to be fully adopted by the industry due to many reasons, such as focusing on the data plane programmability as well as enabling programmability for specific network devices vendors. Although some of the SDN concepts are not new, it integrates the concepts of programmability in the network architecture in order to offer better network management strategies. In this scenario, Open Flow \hyperref[b1]{[2]} has been considered the de facto and widely accepted solution to implement SDN. It is worth emphasizing that Open Flow and SDN terms cannot be used interchangeably.\par
Although some previous studies \hyperref[b10]{[11]} [12] [13] \hyperref[b13]{[14]} have surveyed the state-of-the-art on SDN programmability, we take a different perspective on the topic by describing the techniques, methodologies, and challenges to develop and deploy SDN software applications. We provide a unique view from the perspective of the Software Engineering discipline in which we present the evolution, current maturity, and point out prospective research directions and challenges to develop applications for SDN. 
\section[{II. Software Defined Networking}]{II. Software Defined Networking}\par
The separation of the control plane from the forwarding plane is one of the pillars of the SDN paradigm. Its decoupled architecture enables network programmability. Historically, the research community made several attempts to provide network programmability, where Active Networking (AN) and Open Signaling (Opening) are considered the seminal approaches \hyperref[b6]{[7]}. 
\section[{a) SDN Architecture}]{a) SDN Architecture}\par
When the control logic is decoupled from the forwarding devices, all the network intelligence (e.g., decisions about routing, permissions) is moved to the controller. The SDN controller becomes the network component responsible for network management, as Open Flow is a protocol that defines an open standard interface for SDN, and uses a programmable controller to communicate with the forwarding plane, manage the network, and possibly receive instructions from a network application. Such an interface has a lowlevel implementation, which offers basic features to developers. The complexity involved in developing advanced SDN software applications needs to be addressed by other means (e.g., via new programming languages), in order to increase its level of abstraction. In this scenario, full development and deployment of such applications in staging and production environments remains a challenge for network operators \hyperref[b9]{[10]}. 
\section[{Keywords:}]{Keywords:}\par
software defined networking, SDN programming languages, software engineering.\par
Figure \hyperref[fig_0]{1} depicts. Management then occurs through a flow table present in the network switches, which receive and register network rules defined by the controller (cf. section II. C). In other words, the SDN controller adds flow table entries in the switches for proper packet or flow handling. The controller has all the necessary network information (e.g., where the hosts are connected, topology, and the like) that it uses to deal with possible conflicts involving policies or to avoid misbehaviour of network elements. As Figure \hyperref[fig_0]{1} depicts, the controller has two main interfaces, namely i) the northbound interface, for higher-level elements to support the development of network applications and services, or to program the SDN controller through a well-defined API and ii) the southbound interface, for the communication between controllers and network switches. The SDN controllers are strategic control elements that communicate with the underlying switches (via SI) and with applications on the top (via NI). An SDN controller sends messages to switches disseminating specific or general packet handling rules, which are generally defined by a developer or administrator through the controller's northbound API  {\ref [13] [14]}. 
\section[{c) The open flow protocol}]{c) The open flow protocol}\par
The Open Flow protocol defines how the exchange of information between control-plane and data-plane must occur .When an Open Flow switch receives a packet, its header fields are verified and compared to related fields in the flow table entries. If an entry corresponds to this packet header, the switch will perform the set of instructions or actions related with the flow entry. 
\section[{III. Programming Paradigms, Languages Specification, and Software Engineering in SDN}]{III. Programming Paradigms, Languages Specification, and Software Engineering in SDN}\par
The paradigm for programming languages applications development is the declarative, used in most research papers in the literature [04]  {\ref [10] [14]}. Declarative programming languages have been characterized by its extremely formal nature, often based on logic, but without arithmetic  {\ref [42]}. This paradigm allows a developer to define what action needs to be done in the network, but not how this action will do it. Please note that this definition applies to all declarative programming languages. To make it possible, a language interpreter is used to translate the "what" into "how". An example involving this approach in an SDN scenario is shown below, using the Frenetic notation \hyperref[b9]{[10]}: The example presented in Figure 3 demonstrates a high-level declaration to filter packets in a given flow, which does not require the programmer's knowledge to implement how the Select(packets) clause will receive and direct the packets to some program or service that is requesting it.Select(packets) * GroupBy([srcmac]) * SplitWhen([inport]) * Limit(1)\par
Another widely used paradigm present in SDN programming languages is the Functional Reactive Programming (FRP). FRP is a well-suited solution for the development of event-driven applications, such as SDN applications, enabling programs to capture the time flow property pertinent to SDN systems \hyperref[b12]{[13]}.The reactive characteristic of FRP is direct related to the SDN environment, where switches and controllers continuously exchange information upon packet arrival and apply rules to the corresponding flow. When an SDN language follows the FRP paradigm, it automatically administers the time flow and the dependencies between data and computation.\par
The main idea behind FRP is to define everything in terms of signals. A signal is an element in which its values change in the course of time \hyperref[b13]{[14]} (e.g., if a variable switch is equal to false, its value might changes to true due to emission of a signal). IV. Analysis of use Cases and Applications for SDN Programming Languages\par
Prospective environments for SDN scenarios drive us to analyze a number of specific applications and use cases for SDN programmability. All the languages analyzed in this survey have use cases and evaluation scenarios in their respective publications. This section then presents an overview of the SDN programming languages and their possible applications to be developed. Initially we describe and categorize the applications in the use cases previously defined in this survey. Then, we map these applications and use cases to the SDN programming languages that may be used by developers to write them, as shown in Table  {\ref 3}. This mapping defines the lessons learned in this survey, providing directions on what language to use in developing SDN applications.\par
Admission Control: An admission control application enables the administrator to specify the authentication rules for hosts and users that try to access the network. Admission control applications can be implemented through an SDN programming language to define what default connectivity is allowed and which authentication mechanisms will be used. Load Balancing: The load balancing use case might be seen as a congestion-aware routing for networks  {\ref [76]}. With a load balancing application, the controller prevents overload instructing the switches how to balance the incoming traffic among the network paths. 
\section[{Quality of Service (QoS):}]{Quality of Service (QoS):}\par
For QoS applications, developers may use how resources should be allocated to different users and flow classes. This is done by setting some network properties, such as latency and available bandwidth. These applications to fit in the Applications-based Network use case. This is because end-user software can communicate with the SDN controller, which must be running a QoS application, to request some network resource.\par
NAT Administration: The Network Address Translation (NAT) Administration is generally used to enable multiple machines within a private IP range to share a single public IP address, mapping two pools of IP addresses. This translation requires an implementation which alters the IP and port number of each packet in the private network. This is the basic difference between NAT and others applications mentioned. In NAT administration, each packet in the flow must be modified, therefore requiring the network switches to support this functionality. In the SDN scenario, the NAT administration application may be executed on the controller, which installs rules into switches to perform the modification of headers of certain packets corresponding to IP addresses and port numbers that should have a specific quality \hyperref[b10]{[11]}. Security Rules: A typical example of security rules is the implementation of an IP addresses black list module that prevents a malicious IP source addresses from sending traffic. Fault Tolerance: An interesting use case involves network resilience scenarios. For instance, in the case of a link failure, the network should be able to choose a backup path dynamically. Deep Packet Inspection: It is a network application which examines packet's payload looking for patterns, such as from well-known applications and services, viruses, attacks, and the like. In SDN, the controller executes some algorithm to perform DPI. SDN languages as Frenetic \hyperref[b9]{[10]} and NetCore \hyperref[b12]{[13]} have features to implement DPI applications.\par
After the text edit has been completed, the paper is ready for the template. Duplicate the template file by using the Save As command, and use the naming convention prescribed by your conference for the name of your paper. In this newly created file, highlight all of the contents and import your prepared text file. You are now ready to style your paper; use the scroll down window on the left of the MS Word Formatting toolbar. Cloud Orchestrator: The Cloud Orchestration use case needs a software orchestrator in order to manage the network and the virtual machines. All SDN languages partially enable the implementation of such a software, because they only provide methods to implement a network application, which in this case may create the network orchestrator. The orchestrator of virtual machine needs to be developed with third parties programming languages or obtained from vendors. Policy Specification: The most basic feature of an SDN application and environment is the specification of policies. All the analyzed SDN programming languages enable the implementation of policies in several ways, as well as applications to define the network behavior through policies. However, they differ in the way of writing and implementing these policies in practice. Network Monitor: Foster et al. \hyperref[b15]{[16]} argue that querying network state is one of the fundamental elements in programming SDNs. A Network Monitor application in SDN can observe and request several types of information (e.g., packet counter state in a switch). All languages analyzed allow the implementation of applications that monitor network states. Correctness: The verification and validation of network applications are desired features \hyperref[b13]{[14]}  \hyperref[b14]{[15]}. SDN programming languages might offer constructs that help developers to avoid network misbehavior (i.e., verification), and to build correct applications (i.e., validation), according to the specified requirements. 
\section[{V. Future Work}]{V. Future Work}\par
How to handle network failures? A recurrent discussion on SDN research involves handling of failures. Failures can occur in the availability of a controller or even in wrong policy rules defined by an SDN application. The authors of FatTire argue that programmers do not write programs using the primitive fast-failover OpenFlow mechanisms directly due to the increment of complexity in failure-handling control, which might make code more complex. In order to handle failures in SDN programming, the language needs to support an abstraction of the OpenFlow forwarding table called a group table. Group table consists of group entries. The ability for a flow entry to point a group enables OpenFlow to represent more methods of forwarding \hyperref[b15]{[16]}. It enables multiple conditional rules in OpenFlow. One of the group table types is the fast failover (FF). The fast failover determine that if a flow entry belongs to this group type, the first action bucket (an ordered list of actions) will be performed.\par
FatTire \hyperref[b13]{[14]} abstracts the construction of a fast failover group table, generating the entries in such group table automatically. This approach avoids the error-prone development made by programmers when interacting with fast failover group table directly \hyperref[b13]{[14]}.\par
From the Software Engineering perspective, the development of fault-tolerant applications must be based on languages that define dependable features or build rules created from formal methods. For instance, a language that provides modular development may enable an SDN application to run as redundant modules in replicated controllers, thus improving the recovering time of a network failure. However, synchronizing such modules is not a trivial task \hyperref[b12]{[13]}.\par
How to avoid conflicting rules? This is a challenge investigated by some research studies (e.g., PANE [80], Pyretic \hyperref[b15]{[16]}). Avoiding conflicts means that a policy rule X does not invalidate a policy rule Y, and vice-versa, simultaneously, so that at least one policy rule should be correctly applied. In \hyperref[b15]{[16]},  {\ref Hinrichs et al.} proposed two conflict resolution mechanisms, which we consider a valuable path to effective SDN programming, i.e. one has its features at the level of keywords, identifying the conflicting policies. The other mechanism is a schema that defines priority to each keyword (e.g. the keyword deny has precedence over the keyword allow). A similar approach can be also found in \hyperref[b14]{[15]}. One possible approach to address conflicts in policies could be based on a DSML. In such an approach, invalid policies that result in conflicts could not be created due to the constraints contained in an underlying metamodel.\par
How can one realize automated tests? In order to identify inconsistencies or unexpected states in an SDN application, Canini et al. \hyperref[b11]{[12]} and Vissichio et al. \hyperref[b11]{[12]} propose approaches to realize tests in SDN applications. End-host applications and switches affect the program running on the controller. In \hyperref[b9]{[10]}  How to abstract the complexity in SDN development efficiently? The low level of abstraction used by OpenFlow and its releases makes it hard to program applications and to define a desired behavior into the network. The studies analyzed suggest that a decomposition of the controller, through one relationship with the OpenFlow protocol and adding a layer to specify policies, reduces the complexity to develop and deploy SDN applications, mainly due to the readiness to build applications without the need to worry about maintaining consistency of various rules present in an SDN environment. Therefore, such an abstraction is more than only adding more layers for SDN architecture or controllers; it also provides smart structures that reduce the complexity in SDN applications development, and not just encapsulating the methods from the underlying structures. Furthermore, this layering and efficient structures can be used by some DSML, further increasing the level of abstraction, enabling the concrete visualization of network behavior.\par
Be reactive or proactive? The proactive or reactive behavior and structure of a certain SDN language will depend closely on the controller and how packet handling occurs. It is worth emphasizing that one could follow a hybrid approach, where a combination of both strategies allows the flexibility from reactive paradigm to particular sets of traffic control, while proactively providing low latency routing for ordinary traffic. Creating a framework or SDN language to support these two main approaches seems to be the most correct way to achieve completeness. As far as we are concerned to create an SDN language, the possibility of defining a DSML enables developers to develop high-quality SDN applications. This isdue to the ability of DSML to raise the level of abstraction in software programming, because its visual representations are easier to understand than the syntax of textual programming languages.\par
How to improve the SDN programmability? Although this question allows a number of answers, we aim at presenting and discussing the four most important issues that need improvements: i) verifying and validating applications (e.g., consistent updates, rules, and the like), which could be achieved by using DSMLs or constraint checkers in compilers; ii) offering high-level tools for developers, since there is no widespread tool (e.g., Integrated Development Environment -IDE, CASE tool) for creating SDN applications; iii) providing programming languages independent from the underlying controllers or southbound protocols, which fortunately there are some efforts in this direction, such as P4; and iv) writing applications that meet network dependable requirements. 
\section[{VI. Conclusion}]{VI. Conclusion}\par
Some current challenges show that the programming of SDN applications is still complex and not completely standardize. Although there are several abstractions at application level for SDN there are still some issues to be addressed such as interoperability, fault handling, conflict resolution or detection. SDN offers the opportunity of innovative and powerful networking scenarios, the development of correct application with efficiency and efficacy is still work in the progress. In particular advance study MDD/DSML is a possible research path in order to achive correctness, completeness and ease of use and productivity.\begin{figure}[htbp]
\noindent\textbf{1}\includegraphics[]{image-2.png}
\caption{\label{fig_0}Figure 1 :}\end{figure}
    \begin{figure}[htbp]
\noindent\textbf{} \par 
\begin{longtable}{}
\end{longtable} \par
 
\caption{\label{tab_0}}\end{figure}
 			\footnote{© 2017 Global Journals Inc. (US)} 		 		\backmatter  			 
\subsection[{This page is intentionally left blank}]{This page is intentionally left blank}			 			  				\begin{bibitemlist}{1}
\bibitem[Monsanto et al. (2012)]{b4}\label{b4} 	 		\textit{A Compiler and Run-time System for Network Programming Languages},  		 			A Monsanto 		,  		 			N Foster 		,  		 			R Harrison 		,  		 			D Walker 		.  		January 2012. p. .  	 
\bibitem[Strembeck and Zdun (2009)]{b11}\label{b11} 	 		‘An approach for the systematic development of domain-specific languages’.  		 			M Strembeck 		,  		 			U Zdun 		.  	 	 		\textit{Journal Software-Practice \& Experience}  		Oct 2009. p. .  	 
\bibitem[Özgür ()]{b1}\label{b1} 	 		\textit{Comparison of Microsoft DSL Tools and Eclipse Modeling Frameworks for Domain-Specific Modeling In the context of the Model Driven Development},  		 			T Özgür 		.  		2007. p. 56.  		 			School of Engineering. Ronneby, Sweden: Blekinge Institute of Technology 		 	 
\bibitem[Monsanto et al. ()]{b5}\label{b5} 	 		\textit{Composing Software-Defined Networks},  		 			A Monsanto 		,  		 			J Reich 		,  		 			N Foster 		,  		 			J Rexford 		,  		 			D Walker 		.  		2013. NSDI.  	 
\bibitem[Case ()]{b15}\label{b15} 	 		‘Computer-aided software engineering (CASE): technology for improving software development productivity’.  		 			F Case 		.  	 	 		\textit{ACM SIGMIS Database}  		1985. 17 p. .  	 
\bibitem[Van Deursen et al. ()]{b14}\label{b14} 	 		\textit{Domain-Specific Languages: An Annotated Bibliography},  		 			A Van Deursen 		,  		 			P Klint 		,  		 			J Visser 		.  		2000. p. .  	 	 (Sigplan Notices 35.6) 
\bibitem[Gronback ()]{b0}\label{b0} 	 		 			R C Gronback 		.  		\textit{Eclipse Modeling Project: A Domain-Specific Language (DSL) Toolkit},  				2009. Addison-Wesley Professional.  	 
\bibitem[Foster et al. (2013)]{b9}\label{b9} 	 		\textit{Languages for Software-Defined Networks},  		 			N Foster 		,  		 			M J Freedman 		,  		 			A Guha 		,  		 			R Harrison 		,  		 			N K Praveen 		,  		 			C Monsanto 		,  		 			J Reich 		,  		 			M Reitblatt 		,  		 			J Rexford 		,  		 			C Schlesinger 		,  		 			A Story 		,  		 			D Walker 		.  		February 2013. IEEE Communication Magazine.  	 
\bibitem[Katta et al. ()]{b6}\label{b6} 	 		‘Logic Programming for Software-Defined Networks’.  		 			N P Katta 		,  		 			J Rexford 		,  		 			D Walker 		.  	 	 		\textit{ACM SIGPLAN Workshop on Cross-Model Language Design and Implementation}  		2012.  	 
\bibitem[Frankel ()]{b16}\label{b16} 	 		\textit{Model Driven Architecture: Applying MDA to Enterprise Computing},  		 			D Frankel 		.  		2002. New York, NY, USA: John Wiley \& Sons, Inc.  	 
\bibitem[Schmidt (2006)]{b13}\label{b13} 	 		‘Model-Driven Engineering’.  		 			D C Schmidt 		.  	 	 		\textit{IEEE Computer}  		February 2006. 39  (2) .  	 
\bibitem[Voellmy et al. (2011)]{b3}\label{b3} 	 		‘Nettle: Functional Reactive Programming for OpenFlow Networks’.  		 			A Voellmy 		,  		 			A Agarwal 		,  		 			P Hudak 		.  	 	 		\textit{PADL}  		July 2011.  	 
\bibitem[Koponen et al. (2014)]{b7}\label{b7} 	 		‘Network virtualization in multi-tenant datacenters’.  		 			T Koponen 		,  		 			K Amidon 		,  		 			P Balland 		,  		 			M Casado 		,  		 			A Chanda 		,  		 			B Fulton 		,  		 			I Ganichev 		,  		 			J Gross 		,  		 			P Ingram 		,  		 			E Jackson 		.  	 	 		\textit{11th USENIX Symposium on Networked Systems Design and Implementation},  				April 2014. p. .  	 
\bibitem[Koponen et al. ()]{b10}\label{b10} 	 		‘Onix: A Distributed Control Platform for Large-scale Production Networks’.  		 			T Koponen 		,  		 			M Casado 		,  		 			N Gude 		,  		 			J Stribling 		,  		 			L Poutievski 		,  		 			M Zhu 		,  		 			R Ramanathan 		,  		 			Y Iwata 		,  		 			H Inoue 		,  		 			T Hama 		,  		 			S Shenker 		.  	 	 		\textit{USENIX OSDI},  				Octuber 2010. p. .  	 
\bibitem[Hinrichs et al. (2009)]{b2}\label{b2} 	 		\textit{Practical Declarative Network Management},  		 			T L Hinrichs 		,  		 			N S Gude 		,  		 			M Casado 		,  		 			J C Mitchell 		,  		 			S Shenker 		.  		August 2009.  	 
\bibitem[Voellmy et al. ()]{b12}\label{b12} 	 		‘Procera: a language for high-level reactive network control’.  		 			A Voellmy 		,  		 			H Kim 		,  		 			N Feamster 		.  	 	 		\textit{HotSDN '12 Proceedings of the first workshop on Hot topics in software defined networks},  				2012. p. .  	 
\bibitem[Stahl et al. ()]{b17}\label{b17} 	 		 			T Stahl 		,  		 			M Voelter 		,  		 			K Czarnecki 		.  		\textit{Model-Driven Software Development: Technology, Engineering, Management},  				2006. John Wiley \& Sons.  	 
\bibitem[Nelson et al. (2014)]{b8}\label{b8} 	 		‘Tierless Programming and Reasoning for Software-Defined Networks’.  		 			T Nelson 		,  		 			A D Ferguson 		,  		 			M J Scheer 		,  		 			S Krishnamurthi 		.  	 	 		\textit{Proceedings of the 11th USENIX Symposium on Networked Systems Design and Implementation},  				 (the 11th USENIX Symposium on Networked Systems Design and Implementation)  		2-4 April 2014.  	 
\end{bibitemlist}
 			 		 	 
\end{document}
