Choosing Appropriate Programming Language to Implement Software for Real-Time Resource-Constrained Embedded Systems

ion and offers a better O-O programming style, but some of its features may cause degradation in program efficiency (Barr, 1999). Also, such a new generation O-O language is not readily available for the small embedded systems, primarily because of the overheads inherent in the O-O approach, e.g. CPU-time overhead (Pont, 2003). Despite that Ada was a leading language that provided full support for concurrent and realtime programming, it has not gained much popularity (Brosgol, 2003) and has rarely been used outside the areas related to defense and aerospace applications (Barr, 1999; Ciocarlie & Simon, 2007). Unlike C, not many programmers nowadays are experienced in Ada, therefore only a small number of embedded systems are currently developed using this language (Ciocarlie & Simon, 2007). In addition, despite their approved efficiency, Ada compilers are not widely available for small embedded microcontrollers and usually need hard work to accept the program; especially by new programmers (Dewar, 2006). Indeed, both Ada and C++ have too large demand on low-cost embedded systems resources (e.g. memory requirements) and therefore cannot be suitable languages for such applications1 (Walls, 2005). 1 However, despite the indicated limitations of Ada, there has been a great deal of work on assessing a new version of Ada language (i.e. Ada-2005) to widen its application domain (see Burns, 2006; Taft et al., 2007). It has been noted that Ada-2005 can have the potential to overwhelm the use of “C” and its descendants in embedded systems programming (Brosgol and Ruiz, 2007).


Introduction
In embedded systems development, engineers are concerned with both software and hardware aspects of the system.Once the design specifications of a system are clearly defined and converted into appropriate design elements, the system implementation process can take place by translating those designs into software and hardware components.People working on the development of embedded systems are often concerned with the software implementation of the system in which the system specifications are converted into an executable system (Sommerville, 2007;Koch, 1999).For example, Koch interpreted the implementation of a system as the way in which the software program is arranged to meet the system specifications.
Having decided on the software architecture of the embedded design, the first key decision to be made in the implementation stage is the choice of programming language to implement the embedded software (including the scheduler code, for example).The choice of programming language is an important design consideration as it plays a significant role in reducing the total development time (Grogono, 1999) (as well as the complexity and thus maintainability and expandability of the software).This chapter is intended to be a useful reference on "computer programming languages" in general and on "embedded programming languages" in particular.The chapter provides a review of (almost) all common programming languages used in computer science and realtime embedded systems.The chapter then discusses the key challenges faced by an embedded systems developer to select a suitable programming language for their design and provides a detailed comparison between the available languages.A detailed literature review of the work done in this area is also provided.The chapter also provides real data which shows that -among the wide range of available choices -"C" remains the most popular language for use in the programming of real-time, resource-constrained embedded systems.The key features of "C" which made it so popular are provided in a great detail.
The chapter is organized as follows.Section 2 provides various definitions of the term "programming language" from a wide range of well-known references.Section 3 and Section 4 provide classification and history of programming languages (respectively).Section 5 provides a review of programming languages used in the fields of real-time embedded systems.Section 6 discusses the choice of programming languages for embedded designs.Section 7 and Section 8 provide the main advantages of "C" which made it the most popular language to use in real-time, resource-constrained embedded systems and a detailed comparison with alternative languages (respectively).Real data which shows the prevalence of "C" against other available languages is also provided in Section 8. Section 9 presents a brief literature review of using "C" to implement software for real-time embedded systems.The overall chapter conclusions are drawn in Section 10.

What is a programming language?
Simply, programming as a problem has only arisen since computer machines were first created.The magnitude of the problem is however relative to the size (and complexity) of the computer machine used (Cook, 1999).To program a computer system, a programming language is required.The latter is seen as the major way of communication (interface) between a person who has a problem and the computer system used to solve the problem.
Programming language has been defined in several ways.For example, American Standard Vocabulary for Information Processing (ANSVIP, 1970) defined a programming language as "A language used to prepare computer programs".The IFIP-ICC Vocabulary of Information Processing (IFIP-ICC, 1966) defined it as "A general term for a defined set of symbolic and rules or conventions governing the manner and sequence in which the symbols may be combined into a meaningful communication".The IFIP-ICC glossary also noted that "An unambiguous language, intended for expressing programs, is called a PROGRAMMING LANGUAGE".Other definitions for a programming language include:


"A computer tool that allows a programmer to write commands in a format that is more easily understood or remembered by a person, and in such a way that they can be translated into codes that the computer can understand and execute."(Budlong, 1999). "An artificial language for expressing programs."(ISO, 2001). "A self-consistent notation for the precise description of computer programs" (Wizitt, 2001). "A standard which specifies how (sort of) human readable text is run on a computer."(Sanders, 2007). "A precise artificial language for writing programs which can be automatically translated into machine language."(Holyer, 2008).
However, it was noted elsewhere (e.g.Sammet, 1969) that standard definitions are usually too general as they do not reflect the language usage.A more specific definition for a programming language was given by Sammet as a set of characters and rules (used to combine the characters) that have the following characteristics:  A programming language requires no knowledge of the machine code by the programmer, thus the programmer can write a program without much knowledge about the physical characteristics of the machine on which the program is to be run.


A programming language should be machine independent. When a program written in a programming language is translated into the machine code, each statement should explode to generate a large set of machine instructions.


A programming language must have problem-oriented notations which are closer to the specific problem intended to be solved.
It is worth mentioning that a vast number of different programming languages have already been created, and new languages are still being created.
In  (Pont, 2003).For example, Jalote (1997) noted that using O-O helps to represent the problem domain, which makes it easier to produce and understand designs.
In addition to programming paradigm, the purpose of use is an important characteristic of a language: it is unlikely to see one language fitting all needs for all purposes (Sammet, 1969).Programming languages can be divided, according to their purpose, into general-purpose languages, system programming languages, scripting languages, domain-specific languages, and concurrent / distributed languages (or a combination of these).A generalpurpose language is a type of programming language that is capable of creating various types of programs for various applications, e.g."C" language.There has been an argument that some of the general-purpose languages were designed mainly for educational purposes (Wirth, 1993).A system programming language is a language used to produce software which services the computer hardware rather than the user, e.g.Assembly and Embedded C. Scripting language is a language in which programs are a series of commands that are interpreted and then executed sequentially at run-time without compilation, e.g.JavaScript (used for web page design).Domain-specific programming languages are, in contrast to general-purpose languages, designed for a specific kind of tasks, e.g.Csound (used to create audio files), and GraphViz (used to create visual representations of directed graphs).Concurrent languages are programming languages that have abstractions for writing concurrent programs.A concurrent program is the program that can execute multiple tasks simultaneously, where these tasks can be in the form of separate programs or a set of processes or threads created by a single program.Concurrent programming can support distributed computing, message passing or shared resources.Examples of concurrent programming languages include Java, Eiffel and Ada.
In his famous book (i.e."Programming Languages: History and Fundamentals", 1969), Jean E. Sammet used the following set of defining categories as a way of classifying programming languages: 1) procedural and non-procedural languages; 2) problem-oriented, application-oriented and special purpose languages; 3) problem-defining, problem describing and problem solving languages; 4) hardware, publication and reference languages.Sammet however underlined that any programming language can fall into more than one of these categories simultaneously: for further details see Sammet (1969).

History of programming languages
It has been argued that studying the history of programming languages is essential as it helps developers avoid previously-committed mistakes in the development of new languages (Wilson & Clark, 2000).It was also pointed out that an unfortunate trend in Computer Science is creating new language features without carefully studying previous work in this field (Grogono, 1999).Most books and articles on the history of programming languages tend to discuss languages in terms of generations where languages are classified by age (Cook, 1999).Many articles and books have discussed the generations of programming languages (e.g.Wexelblat, 1981;Martin & Leben, 1986;Watson, 1989;Zuse, 1995;Flynn, 2001).Pont (2003) provides a list of widely-used programming languages classified according to their generations (see Table 1).
In the 1940s, the first electrically powered digital computers were created.The computers of the early 1950s used machine language which was quickly superseded by a second generation of programming languages known as Assembly languages.The limitations in resources (e.g. computer speed and memory space) enforced programmers to write their hand-tuned assembly programs.However, it was shortly realized that programming in assembly required a great deal of intellectual effort and was prone to error.It is important to note that although many people consider Assembly as a standard programming language, some others believe it is too low-level to bring satisfactory of communication for user, hence was excluded from the programming languages list (Sammet, 1969).
1950s saw the development of a range of high-level programming languages (some of which are still in widespread use), e.g.FORTRAN, LISP, and COBOL, and other languages such as Algol 60 that had a substantial influence on most of the lately developed programming languages.In 1960s, languages such as APL (A Programming Language), Simula, BASIC and PL/I were developed.PL/I incorporated the best ideas from FORTRAN and COBOL.Simula is considered to be the first language designed to support O-O programming.
The period between late 1960s and late 1970s brought a great prosperity to programming languages most of which are used nowadays.In the mid-1970s, Smalltalk was introduced with a complete design of an O-O language.The programming language "C" was developed between 1969 and 1973 as a systems programming language, and remained popular.In 1972, Prolog was designed as the first logic programming language.In 1978, ML (Meta-Language) was developed to found statically-typed functional programming languages in which type checking is performed during compile-time allowing more efficient program execution.It is important to highlight that each of these languages originated an entire family of descendants.Some other key languages which were developed in this period include: Pascal, Forth and SQL (Structured Query Language).
In 1980s, C++ was developed as a combined O-O and systems programming language.Around the same time, Ada was developed and standardized by the United States government as a systems programming language intended for use in defense systems.One noticeable tendency of language design during the 1980s was the increased focus on programming large-scale systems through the use of modules, or large-scale organizational units of code.Therefore, languages such as Modula-2, Ada, and ML were all extended to support such modular programming in 1980s.Some other languages that were developed in this period include: Eiffel, PEARL (Practical Extraction and Report Language) and FL (Function Level).
In mid-1990s, the rapid growth of the Internet created opportunities for new languages to emerge.For example, PEARL (which is originally a Unix scripting tool first released in 1987) became widely adopted in dynamic web sites design.Another example is Java which was commonly used in server-side programming.These language developments provided no fundamental novelty: instead, they were modified versions of existing languages and paradigms and largely based on the "C" family of programming languages.
It is difficult to determine which programming languages are most widely used, as there have been various ways to measure language popularity (see O'Reilly, 2006;Bieman & Murdock, 2001).Mostly, languages tend to be popular in particular types of applications.For example, COBOL is a leading language in business applications (Carr & Kizior, 2000), FORTRAN is widely used in engineering and science applications (Chapman, 2004), and "C" is a genuine language for programming embedded applications and operating systems (Barr, 1999;Pont, 2002;Liberty & Jones, 2004).

Programming languages for real-time embedded systems
To develop a real-time embedded system, a number of tools and techniques would be required: the key one is the programming language used to develop the application code (Burns, 2006).Assembly was the first programming language used to implement the software for embedded applications.However, it was argued that the development environments that used the first generation languages such as Assembly lacked the basic support for debugging and testing (Halang & Stoyenko, 1990).Therefore, in 1960s, the need for high-level programming languages to program real-time systems, instead of continuing to use Assembly language, was agreed among many real-time system designers; due to advantages such as ease of learning, programming, understanding, debugging, maintaining and documenting and also code portability (see Boulton & Reid, 1969;Sammet, 1969).
The work in this area began by identifying the essential requirements for a high-level language to fulfill the objectives of real-time applications (Opler, 1966).Such requirements were summarized by Boulton & Reid (1969) as methods of handling real-time signals and interrupts, and methods of scheduling real-time tasks.Opler (1966) argued that to achieve such requirements, one can make extensions / modifications to an existing programming language, where an alternative solution is to develop new languages dedicated specifically for real-time software.Some success, in extending existing languages to real-time computing, was achieved using languages such as FORTRAN (e.g.Jarvis, 1968;Roberts, 1968;Hohmeyer, 1968;Mensh & Diehl, 1968;Kircher & Turner, 1968) and PL/I (e.g.Boulton & Reid, 1969).Some other studies, however, attempted to develop new real-time languages but with some similarity to existing languages, e.g.PROSPRO (Bates, 1968), SPL (Oerter, 1968) and RTL (Schoeffler & Temple, 1970).
In 1970s, a major concern of many researchers became the programming of real-time applications which involve concurrent processing.Useful work in this area demonstrated that, same as before, concurrent programming can be achieved by either extending available general-purpose languages (e.g.Hansen, 1975;Wirth, 1977) or developing entirely new concurrent-processing languages (e.g.Schutz, 1979).However, it was noticed that extended general-purpose languages still lacked genuine concurrency and real-time concepts (Steusloff, 1984).This led to the development of more efficient concurrent real-time languages such as PEARL (DIN, 1979), ILIAD (Schutz, 1979) and Ada (Ada, 1980).
Ada is a well-designed and widely used language for implementing real-time systems (Burns, 2006).Therefore, it is worth discussing it in greater detail.As previously noted, Ada is an object-oriented, high-level programming language which was first developed and adopted by the U.S. Department of Defense (DoD) to implement various defense missioncritical software applications (Ada, 1980;Baker & Shaw, 1989).Ada appeared as a standard language in 1983 -when Ada83 was released -and was later reviewed and improved in 1995 by producing Ada95.Since developed, Ada has gained a great deal of interest by many real-time and embedded systems developers (e.g.see Real-Time Systems (RTS) Group webpage, The University of York, UK).It was declared that Ada embodies features which facilitate the achievement of safety, reliability and predictability in the system behavior (Halang & Stoyenko, 1990).Halang & Stoyenko (1990) carried out a detailed survey on a number of representative real-time programming languages including Ada, FORTRAN, HALL/S, LTR, PEARL, PL/I and Euclid, and concluded that Ada and PEARL were the most widely available and used languages among the others which had been surveyed.
In addition to the previous sets of modified and specialized real-time languages, it was accepted that universal, procedural programming languages (such as C) can also be used for real-time programming although they contain just rudimentary real-time features: this is mainly because such languages are more popular and widely available than genuine realtime languages (Halang & Stoyenko, 1990).Later generations of O-O languages such as C++ and Java also have popularity in embedded programming (Fisher et al., 2004).Embedded versions of famous ".Net" languages are gaining more popularity in the field of embedded systems development.However, they are not a favorite choice when it comes to resource constrained embedded systems as they are O-O languages, hence, they require a lot of resources as compared to the requirements of "C".

Choosing a suitable programming language for embedded design
In real-time embedded systems development, the choice of programming language is an important design consideration since it plays a significant role in reducing the total development time (Grogono, 1999).
Overall, it has been widely accepted that the low-level Assembly language suffers high development costs and lack of code portability, and only very few highly-skilled Assembly programmers can be found today (see Barr, 1999;Walls, 2005).If the decision is therefore made not to use the Assembly language due to its inevitable drawbacks, there is no scientific way to select the most optimal high-level programming language for a particular application (Sammet, 1969;Pont, 2002).Instead, researchers tend to discuss the important factors which should be considered in the choice of a language.For example, Sammet (1969) indicated that a major factor in selecting a language is the language suitability to solve the particular classes of problems for which it is intended, and the type of the actual user (i.e.user level of professionalism).It has also been noted by Sammet that factors such as availability on the desired computer hardware, history and previous evaluation, implementation consequences of the language are also key factors to take into account during the language selection process.However, Sammet stressed that a successful choice can only be made if the language includes the required technical features.Specifically, when choosing a language for embedded systems development, the following factors must be considered (Pont, 2003): Embedded processors normally have limited speed and memory, therefore the language used must be efficient to meet the system resource constraints.


Programming embedded systems requires a low-level access to the hardware.For example, there might be a need to read from / write to particular memory locations.
Such actions require appropriate accessing mechanisms, e.g.pointers.


The language must support the creation of flexible libraries, making it easy to re-use code components in various projects.It is also important that the developed software should be easily ported and adapted to work on different processors with minimal changes.


The language must be widely used in order to ensure that the developer can continue to recruit experienced professional programmers, and to guarantee that the existing programmers can have access to information sources (such as books, manuals, websites) for examples of good design and programming practices.
Of course, there is no perfect choice of programming language.However, the chosen language is required to be well-defined, efficient, supports low-level access to hardware, and available for the platform on which it is intended to be used.Against all of these factors, "C" language scores well, hence it turns out to be the most appropriate language to implement software for low-cost resource-constrained embedded systems.Pont (2003) stated that "C's strengths for embedded system greatly outweigh its weaknesses.It may not be an ideal language for developing embedded systems, but it is unlikely that a 'perfect' language will be created".

The "C" programming language
In his famous book "Programming Embedded Systems in "C" and C++", Michael Barr (1999) emphasized that "C" language has been a constant factor across all embedded software development due to the following advantages:


It is small and easy to learn. Its compilers are available for almost every processor in use today.


There are so many experienced "C" programmers around the world.


It is a hardware-independent programming language, a feature which allows the programmer to concentrate only on the algorithm rather than on the architecture of the processor on which the program will be running.
Despite this, Barr highlighted that the key advantage of "C" which made it the favorite choice for many embedded programmers is its low-level nature that provides the programmer with the ability to interact easily with the underlying hardware without sacrificing the benefits of using high-level programming.
In (Grogono, 1999), it was declared that "C" is based on a small number of primitive concepts, therefore it is an easy language to learn and program by both skilled and unskilled programmers.Moreover, Grogono stated that "C" can be easily compiled to produce efficient object code.
In a more recent publication, Pont (2002) stated that "C's strengths for embedded system greatly outweigh its weaknesses.It may not be an ideal language for developing embedded systems, but it is unlikely that a 'perfect' language will be created".According to (Pont, 2002(Pont, , 2003)), the key features of the "C" language can be summarized as follows.


It is a mid-level language with both high-level features (such as support for functions and modules) and low-level features (such as access to hardware via pointers).


It is very efficient, popular and well understood even by desktop developers who programmed on C++ or Java.
 Books, training courses, code examples and websites that discuss the use of the language are all widely available.
In (Jones, 2002), it was noted that features such as easy access to hardware, low memory requirements, and efficient run-time performance make the "C" language popular and foremost among other languages.In (Brosgol, 2003), it was made clear that "C" is the typical choice for programming embedded applications as it is processor-independent, has lowlevel features, can be implemented on any architecture, has reasonable run-time performance, is an international standard, and is familiar to almost all embedded systems programmers.Fisher et al. (2004) emphasized that, in addition to portability and low-level features of the language, C structured programming drives embedded programmers to choose "C" language for their designs.Moreover, it has been clearly noted that "C" cannot be competed in producing a compact, efficient code for almost all processors used today (Ciocarlie & Simon, 2007).
Furthermore, since "C" was recognized as the de facto language for coding embedded systems including those which are safety-related (Jones, 2002;Pont, 2002;Walls, 2005), there have been attempts to make "C" a standard language for such applications by improving its safety characteristics rather than promoting the use of safer languages that are less popular (such as Ada).For example, The UK-based Motor Industry Software Reliability Association (MISRA) has produced a set of guidelines (and rules) for the use of "C" language in safetycritical software: such guidelines are well known as "MISRA C".For more details, see (Jones, 2002).

Why does "C" outperform other languages?
When comparing "C" to other alternative languages such as C++ or Ada, the following observations have been made.C++ is a good alternative to "C" as it provides better data abstraction and offers a better O-O programming style, but some of its features may cause degradation in program efficiency (Barr, 1999).Also, such a new generation O-O language is not readily available for the small embedded systems, primarily because of the overheads inherent in the O-O approach, e.g.CPU-time overhead (Pont, 2003).
Despite that Ada was a leading language that provided full support for concurrent and realtime programming, it has not gained much popularity (Brosgol, 2003) and has rarely been used outside the areas related to defense and aerospace applications (Barr, 1999;Ciocarlie & Simon, 2007).Unlike C, not many programmers nowadays are experienced in Ada, therefore only a small number of embedded systems are currently developed using this language (Ciocarlie & Simon, 2007).In addition, despite their approved efficiency, Ada compilers are not widely available for small embedded microcontrollers and usually need hard work to accept the program; especially by new programmers (Dewar, 2006).Indeed, both Ada and C++ have too large demand on low-cost embedded systems resources (e.g.memory requirements) and therefore cannot be suitable languages for such applications1 (Walls, 2005).
In a survey carried out by Embedded Systems Design (ESD) in 2006, it was shown that the majority of existing and future embedded projects to which the survey applied were programmed (and likely to be programmed) in C. In particular, the results show that for 2006 projects, 51% were programmed in C, 30% in C++, and less than 5% were programmed in Ada.The survey shows that 47% of the embedded programmers were likely to continue to use "C" in their next projects.See Fig. 1 for further details.The figure is derived from the data provided in (Nahas, 2008).

Using "C" to implement software for real-time embedded systems
Since "C" remains the most popular means for developing software in real-time embedded systems, it has been extensively used in the implementation of real-time schedulers and operating systems for embedded applications.In general, "C" was adopted in the software development of almost all operating systems (including RTOSs) in which schedulers are the core components (Laplante, 2004).In Michael Barr's book on embedded systems programming (i.e.Barr, 1999), it was noted that "C" is the main focus of any book about embedded programming.Therefore, most of the sample codes presented in Barr's book -for both schedulers and operating systems -were written in "C" and the key focus of the discussion was on how to use "C" language for 'in-house' embedded software development.However, some of the example code presented later in the book was written in C++ while Assembly language was avoided as much as possible.In (Barr & Massa, 2006), possible ways for implementing the eCos and the Embedded Linux, as a small and a large opensource operating systems (respectively), in "C" language were discussed.Other books which discuss the use of "C" language in the software implementation of real-time embedded systems include (Ganssle, 1992;Brown, 1994;Sickle, 1997;Zurell, 2000;Labrosse , 2000;Samek, 2002;Barnett et al., 2003;Laplante, 2004).
More specifically, using "C" language to implement the software code for particular scheduling algorithms is quite common.For example, Mooney et al. (1997) described a strategy for implementing a dynamic run-time scheduler using both hardware and software components: the software part was implemented using "C" language.Kravetz & Franke (2001) described an alternative implementation of the Linux operating system scheduler using "C" programming.It was emphasized that the new implementation can maintain the existing scheduler behavior / semantics with very little changes in the existing code.Rao et al. (2008) discussed the implementation of a new pre-emptive scheduler framework using "C" language.The study basically reviewed and extracted the positive characteristics of existing pre-emptive algorithms (e.g.rate monotonic, EDF and LLF) to implement a new robust, fully pre-emptive real-time scheduler aimed at providing better performance in terms of timing and resource utilization.
Researchers of the Embedded Systems Laboratory (ESL), University of Leicester, UK have been greatly concerned with developing techniques and tools to support the design and implementation of reliable embedded systems, mainly using "C" programming language.An early work in this area was carried out by Pont (2001) which described techniques for implementing Time-Triggered Co-operative (TTC) architectures using a comprehensive set of "software design patterns" written in "C" language.The resulting "pattern language" was referred to as "PTTES2 Collection" which contained more than seventy different patterns.As experience in this area has grown, this pattern collection has expanded and subsequently been revised in a series of ESL publications (e.g.Pont & Ong, 2003;Pont & Mwelwa, 2003;Mwelwa et al., 2003;Mwelwa & Pont, 2003;Pont et al., 2003;Pont & Banner, 2004;Mwelwa et al., 2004;Kurian & Pont, 2005;Kurian & Pont, 2006b;Pont et al., 2006;Wang et al., 2007, Kurian & Pont, 2007).
In (Nahas et al., 2004), a low-jitter TTC scheduler framework was described using "C" language.Phatrapornnant andPont (2004a, 2004b) looked at ways for implementing lowpower TTC schedulers by applying "dynamic voltage scaling" (DVS) algorithm programmed in "C" language.Moreover, Hughes & Pont (2008) described an implementation of TTC schedulers -in "C" language -with a wide range of "task guardian" mechanisms that aimed to reduce the impact of a task-overrun problem on the real-time performance of a TTC system.On the other hand, various ways in which Time-Triggered Hybrid (TTH) scheduler can be implemented in practice using "C" have been described in (Pont, 2001;Maaita & Pont, 2005;Hughes & Pont, 2008;Phatrapornnant, 2007).The ESL group has also been involved in creating software platforms for distributed embedded systems in which Shared-Clock (S-C) scheduling protocols are employed to achieve time-triggered operation over standard network protocols.All different S-C schedulers were implemented using "C" (for further details, see Pont, 2001;Ayavoo et al., 2007).

Conclusions
Selecting a suitable programming language is a key aspect in the success of the software development process.It has been shown that there is no specific method for selecting an appropriate programming language for the development of a specific project.However, the accumulation of experience along with subjective judgment enables software developers to make intelligent choices of programming languages for different application types.
Embedded software developers utilize different programming languages such as: Assembly, Ada, C, and C++.We have demonstrated that C is the most dominant programming language for embedded systems development.Although other languages may be winning ground when it comes to usage, C remains the de facto language for developing resource-constrained embedded systems which comprise a large portion of today's embedded applications.

Acknowledgement
The research summarized in this paper was partially carried out in the Embedded Systems Laboratory (ESL) at University of Leicester, UK, under the supervision of Professor Michael Pont, to whom the authors are thankful.

Fig. 1 .
Fig. 1.Programming languages used in embedded system projects surveyed by ESD in 2006.The figure is derived from the data provided in(Nahas, 2008).