\chapter{Introduction}\label{chap:introduction}

\begin{wrapfigure}{r}{0.3\textwidth}

\includegraphics[width=4cm]{image/notalogobig.png}

\caption{The official NoTA-logo}

\end{wrapfigure}

\section{What is NoTA?}

\textbf{NoTA} ({\em Network on Terminal Architecture}\index{Network on

Terminal Architecture}) is a framework for communication between software and

hardware modules, designed specifically for the communications \textbf{within}

and \textbf{between} embedded devices. An example of this could be the

communication between the \emph{storage subsystem} and the \emph{audio

subsystem} of a phone or an internet tablet.

NoTA is \textbf{also} a specific implementation of this framework -- the {\em

reference implementation}. This guide is about using that reference

implementation.

NoTA originates from work at the {\em Nokia Research Center}\index{Nokia

Research Center} (NRC). The reference implementation is available on-line for

download from the {\tt notaworld.org}-website\cite{NoTAWorld}.

\section{Goals and audience}

There is quite some material available that discusses the architecture and

concepts underlying NoTA software, but there are comparably few practical

explanations on how to actually {\em use} it. 

The goal of this Programming Guide is to change that. In particular, it

attempts to:

\begin{itemize}

\item provide a good general introduction into NoTA-concepts and how they fit

  together;

\item show how NoTA-based systems can be programmed using the NoTA reference

  implementation.

\end{itemize}

We will, however, \textbf{not} discuss the internal NoTA-protocols (the

\texttt{h\_in} and \texttt{l\_in} protocols) in any detail, nor will we go

through the implementation details of the reference implementation -- except

when needed to clarify the use of the user-visible parts.

The target audience for this guide consists of people who would like to know

how NoTA works in practice, and how NoTA-enabled software can be

implemented. A good working knowledge of the \emph{C}-programming

language\index{C programming language} is very useful, as is some knowledge of

UNIX-like\index{UNIX} platforms.

\section{Structure of this guide}

Although we'd like this to be a very practical introduction into programming

with NoTA, this guide is neither a {\em cookbook} nor a {\em HOWTO}. We want

to provide some background, so the concepts become clearer, and you actually

understand what you are doing. For that reason, we will spend quite some time

with the way NoTA is structured and why things are the way they are.

{\bf Note}: we discuss the {\tt h\_in} in quite a bit of detail in

chapters~\ref{chap:h-in} and~\ref{chap:h-in-example}. This is good from a

structural viewpoint.  However, it may also be a bit more detailed that what

is needed to become productive quickly. So, if you are in a hurry, you might

want to glance over chapter~\ref{chap:h-in}, and then focus on

chapter~\ref{chap:stubgen}, about the stub-generator.

To test your understanding of the material, each of the chapters ends with a

number of questions. The answers to those questions are provided in

appendix~\ref{chap:answers}.

\begin{itemize}

\item Chapter \ref{chap:overview} discusses the NoTA components and

  architecture. It provides background to many of the concepts we are using in

  the rest of this guide;

\item Chapter~\ref{chap:h-in} discusses the {\tt h\_in}, the high-level

  interconnect. The {\tt h\_in} is the layer that application programmers

  usually interact with. The {\tt h\_in} reference implementation provides an

  API similar (but not equal) to BSD-sockets~\cite{Stevens2003};

\item Chapter ~\ref{chap:messages} discusses NoTA-message; using the sockets

  of chapter~\ref{chap:h-in}, we can send requests or receive information from

  other nodes using these messages;

\item Chapter~\ref{chap:h-in-example} provides an example of using the {\tt

    h\_in}, using Caesar Cyphers;

\item Chapter \ref{chap:stubgen} discusses the Stub-Generator ('{\tt

  stubgen}'). Instead of using the {\tt h\_in} directly, the stubgen

  generates much of the plumbing code for both application node and Service

  Node for you from WSDL\index{Web Services Description Language}

  descriptions;

\item Chapter~\ref{chap:stubgen-example} gives an example of using the

  stub-generator, by using it to re-implement the Caesar Cypher example of

  chapter\ref{chap:h-in-example};

\item Chapter~\ref{chap:rm} discusses the resource manager (RM), which

  (roughly) plays the role that DNS plays in internet communications;

\item Chapter~\ref{chap:rm-example} gives an example of using the resource manager;

\item Chapter~\ref{chap:l-in} provides some more background information on the

  \texttt{l\_in}. Although application programmers usually don't have to deal

  with \texttt{l\_in} directly, it's still good to understand the backgrounds;

\item Chapter~\ref{chap:development} puts all the building blocks together,

  and goes through the typical development lifecycle.

\end{itemize}

After that, there are a number of appendices:

\begin{itemize}

\item Appendix~\ref{chap:installation} contains some notes on how to install

  NoTA-software on your system; 

\item Appendix~\ref{chap:building} has instruction on how

  to build your own NoTA-based software;

\item Appendix~\ref{chap:running} discusses running NoTA-based programs;

\item  Appendix~\ref{chap:example} has the source code of all the examples;

\item Appendix~\ref{chap:rm-sis} contains the full WSDL service interface for

  the resource manager;

\item As mentioned, many of the chapters have questions add the end, so you

  can test your understanding. The answers to these questions can be found in

  appendix~\ref{chap:answers}.

\end{itemize}

\section{Questions}

To test your understanding of this chapter, you could try to answer some of

the following questions. You can find the answers in

appendix~\ref{chap:answers}.

\begin{enumerate}

\item Which two things does the name 'NoTA' refer to? What can it be used for?

\item What existing knowledge is recommended for getting the most out of

  this guide?

\item Should you read chapters~\ref{chap:h-in} and~\ref{chap:h-in-example}

  (about the {\tt h\_in} before reading chapter~\ref{chap:stubgen}?

\item Consider the equation $x^n + y^n = z^n$, where $x,y,z,n \in

  \mathbb{N}$. One solution would be $3² + 4² = 5²$. Proof that there are no

  solutions for $n > 2$. As a bonus question, please also prove that ever even

  integer $>2$ can be written as the sum of two prime numbers.

\end{enumerate}