First time in C Programming

Dediary Prasetya
 Writing and Running Programs
#include <stdio.h>
/* The simplest C Program */
int main(int argc, char **argv) 1. Write text of program (source code) using an editor such
{
printf(“Hello World\n”); as emacs, save as file e.g. my_program.c
return 0;
}

2. Run the compiler to convert program from source to an

“executable” or “binary”:
$ gcc –Wall –g my_program.c –o my_program

$ gcc -Wall –g my_program.c –o my_program

tt.c: In function `main':
tt.c:6: parse error before `x'
tt.c:5: parm types given both in parmlist and separately
tt.c:8: `x' undeclared (first use in this function)
tt.c:8: (Each undeclared identifier is reported only once
3-N. Compiler gives errors and warnings; edit source file, fix
tt.c:8: for each function it appears in.)
tt.c:10: warning: control reaches end of non-void function it, and re-compile
tt.c: At top level:
tt.c:11: parse error before `return'

N. Run it and see if it works 

$ ./my_program
my_program Hello World
$▌
2
 C Syntax and Hello World
#include inserts another file. “.h” files are called “header”
files. They contain stuff needed to interface to libraries and
code in other “.c” files.

This is a comment. The compiler ignores this.

#include <stdio.h>
The main() function is always
/* The simplest C Program */ where your program starts
int main(int argc, char **argv) running.
{
printf(“Hello World\n”);
Blocks of code (“lexical scopes”)
are marked by { … }
return 0;
}

Return ‘0’ from this function Print out a message. ‘\n’ means “new line”.
3
 A Quick Digression About the Compiler
#include <stdio.h>
/* The simplest C Program */
int main(int argc, char **argv)
Preprocess Compilation occurs in two steps:
{
printf(“Hello World\n”); “Preprocessing” and “Compiling”
return 0;
}

__extension__ typedef unsigned long long int __dev_t; In Preprocessing, source code is “expanded” into a
__extension__ typedef unsigned int __uid_t;
__extension__ typedef unsigned int __gid_t; larger form that is simpler for the compiler to
__extension__ typedef unsigned long int __ino_t;
__extension__ typedef unsigned long long int __ino64_t; understand. Any line that starts with ‘#’ is a line that is
__extension__ typedef unsigned int __nlink_t;
__extension__ typedef long int __off_t; interpreted by the Preprocessor.
__extension__ typedef long long int __off64_t;
extern void flockfile (FILE *__stream) ;
extern int ftrylockfile (FILE *__stream) ;
extern void funlockfile (FILE *__stream) ; • Include files are “pasted in” (#include)
int main(int argc, char **argv)
{
printf(“Hello World\n”);
• Macros are “expanded” (#define)
}
return 0; • Comments are stripped out ( /* */ , // )
• Continued lines are joined ( \ )

my_program The compiler then converts the resulting text into

Compile
binary code the CPU can run directly.

4
 What is a Function?
A Function is a series of instructions to run. You pass
Arguments to a function and it returns a Value.

“main()” is a Function. It’s only special because it always

gets called first when you run your program.

Return type, or void

Function Arguments
#include <stdio.h>
/* The simplest C Program */
int main(int argc, char **argv)
{ Calling a Function: “printf()” is just another
printf(“Hello World\n”); function, like main(). It’s defined for you in a
“library”, a collection of functions you can call
return 0;
from your program.
}
Returning a value
5
 What is “Memory”?
Addr Value
Memory is like a big table of numbered slots
where bytes can be stored. 0
1
The number of a slot is its Address. 2
One byte Value can be stored in each slot. 3
72?
4 ‘H’ (72)
Some “logical” data values span more than one 5 ‘e’ (101)
slot, like the character string “Hello\n” 6 ‘l’ (108)
7 ‘l’ (108)
A Type names a logical meaning to a span of 8 ‘o’ (111)
memory. Some simple types are:
9 ‘\n’ (10)
char a single character (1 slot) 10 ‘\0’ (0)
char [10] an array of 10 characters
11
int signed 4 byte integer
float 4 byte floating point 12
int64_t signed 8 byte integer
6
 What is a Variable?
Symbol Addr Value
A Variable names a place in memory where you
store a Value of a certain Type. 0
1
You first Define a variable by giving it a name 2
and specifying the type, and optionally an 3
initial value
x 4 ?
y 5 ‘e’ (101)
char x; Initial value of x is undefined
char y=‘e’; 6
7
The compiler puts them
Initial value
somewhere in memory. 8
9
Name
10
11
Type is single character (char)
12
7
 Multi-byte Variables
Different types consume different amounts of Symbol Addr Value
memory. Most architectures store data on 0
“word boundaries”, or even multiples of the 1
size of a primitive data type (int, char) 2
3
char x;
char y=‘e’; x 4 ?
int z = 0x01020304; y 5 ‘e’ (101)
6
0x means the constant is padding
written in hex 7
z 8 4
9 3
An int consumes 4 bytes
10 2
11 1
12
8
ASCII is an abbreviation for American Standard Code for Information Interchange. ASCII was
developed in the 1960s and was based on earlier codes used by telegraph systems
ASCII does not have diacritics (marks that are added to a letter, like the dots (umlauts) above vowels in
German, or the tilde (~) above the 'n' for the 'ñ' used in Spanish).
This led to some systems using 8 bits (a full byte) instead of 7 bits. The proper name for systems that use 8
bits is called extended ASCII. Eight bits allows for 256 characters. The first 128 characters must be the same
as for ASCII and the rest are usually used for alphabetic letters with accents, for example like É, È, Î and Ü.
And some systems like those using Chinese characters still do not work, as they use thousands of characters.
So unicode was created to have one common system for all languages.
 Start

Get Name

Get City

Get date of
birth

Calculate the age

Print: Hi (name), from (city),

(age) years old, and birthday

Stop
#include <stdio.h>
int main()
{
int age, dd,mm,mmm,yy,dy;
char name[20], city[20];

printf("what's your name? ");

gets(name);
printf("where do you live? ");
gets(city);
printf("enter your date of birth!\n");
printf("date : ");
scanf("%d",&dd);
printf("month : ");
scanf("%d",&mm);
printf("year : ");
scanf("%d",&yy);
age=2014-yy;

printf("\n\n\nHi, %s ! from %s , %d years old", name, city, age);

printf("\nyour birthday %d - %d - %d ", dd, mm, yy);

printf("\n\n\nhit any key !");

getch();
return 0;
}
Stop
 Lexical Scoping void p(char x)
Every Variable is Defined within some scope. A {
Variable cannot be referenced by name (a.k.a. /* p,x */
char y;
Symbol) from outside of that scope. /* p,x,y */
char z;
/* p,x,y,z */
}
Lexical scopes are defined with curly braces { }. /* p */
char z;
/* p,z */
The scope of Function Arguments is the
void q(char a)
complete body of the function. {
char b;
/* p,z,q,a,b */
The scope of Variables defined inside a function
{ char b?
starts at the definition and ends at the closing char c;
/* p,z,q,a,b,c */
brace of the containing block }
legal?
char d;
The scope of Variables defined outside a /* p,z,q,a,b,d (not c) */
}
function starts at the definition and ends at the
end of the file. Called “Global” Vars. /* p,z,q */

15
 Expressions and Evaluation
Expressions combine Values using Operators, according to precedence.

1 + 2 * 2  1 + 4  5
(1 + 2) * 2  3 * 2  6

Symbols are evaluated to their Values before being combined.

int x=1;
int y=2;
x + y * y  x + 2 * 2  x + 4  1 + 4  5

Comparison operators are used to compare values.

In C, 0 means “false”, and any other value means “true”.
int x=4;
(x < 5)  (4 < 5)  <true>
(x < 4)  (4 < 4)  0
((x < 5) || (x < 4))  (<true> || (x < 4))  <true>

Not evaluated because

first clause was true 16
 Comparison and Mathematical Operators
== equal to The rules of precedence are clearly
< less than defined but often difficult to remember or
<= less than or equal
> greater than non-intuitive. When in doubt, add
>= greater than or equal parentheses to make it explicit. For oft-
!= not equal
&& logical and
confused cases, the compiler will give you
|| logical or a warning “Suggest parens around …” – do
! logical not it!
+ plus & bitwise and
- minus | bitwise or Beware division:
* mult ^ bitwise xor • If second argument is integer, the
/ divide ~ bitwise not
% modulo << shift left result will be integer (rounded):
>> shift right 5 / 10  0 whereas 5 / 10.0  0.5
• Division by 0 will cause a FPE

Don’t confuse & and &&..

1 & 2  0 whereas 1 && 2  <true>
17
 Assignment Operators
x = y assign y to x x += y assign (x+y) to x
x++ post-increment x x -= y assign (x-y) to x
++x pre-increment x x *= y assign (x*y) to x
x-- post-decrement x x /= y assign (x/y) to x
--x pre-decrement x x %= y assign (x%y) to x

Note the difference between ++x and x++:

int x=5; int x=5;

int y; int y;
y = ++x; y = x++;
/* x == 6, y == 6 */ /* x == 6, y == 5 */

Don’t confuse = and ==! The compiler will warn “suggest parens”.

int x=5; int x=5;

if (x==6) /* false */ if (x=6) /* always true */
{ {
/* ... */ /* x is now 6 */
} }
/* x is still 5 */ /* ... */

18
 A More Complex Program: pow
#include <stdio.h>
“if” statement #include <inttypes.h>

float pow(float x, uint32_t exp)

/* if evaluated expression is not 0 */ {
if (expression) { /* base case */
/* then execute this block */ Need braces? if (exp == 0) {
} return 1.0;
else { }
/* otherwise execute this block */
} /* “recursive” case */
return x*pow(x, exp – 1);
}

int main(int argc, char **argv)

Tracing “pow()”: {
• What does pow(5,0) do? float p;
p = pow(10.0, 5);
• What about pow(5,1)? printf(“p = %f\n”, p);
return 0;
• “Induction” }

Challenge: write pow() so it requires log(exp) iterations

19
 The “Stack”
#include <stdio.h>
Recall lexical scoping. If a variable is valid #include <inttypes.h>
“within the scope of a function”, what happens float pow(float x, uint32_t exp)
when you call that function recursively? Is there {
/* base case */
more than one “exp”? if (exp == 0) {
return 1.0; static
}
Yes. Each function call allocates a “stack frame”
/* “recursive” case */ Java?
where Variables within that function’s scope will return x*pow(x, exp – 1);
}
reside.
int main(int argc, char **argv)
float x 5.0 {
float p;
uint32_t exp 0 Return 1.0 p = pow(5.0, 1);
printf(“p = %f\n”, p);
float x 5.0 return 0;
}
uint32_t exp 1 Return 5.0

int argc 1
char **argv 0x2342
float p undefined
5.0 Grows

20
 Iterative pow(): the “while” loop
float pow(float x, uint exp)
Problem: “recursion” eats stack space (in C). Each {
int i=0;
loop must allocate space for arguments and local float result=1.0;
variables, because each new call creates a new while (i < exp) {
result = result * x;
“scope”. i++;
}
return result;
}
Solution: “while” loop.
int main(int argc, char **argv)
loop: {
if (condition) { while (condition) {
float p;
statements; statements;
p = pow(10.0, 5);
goto loop; }
printf(“p = %f\n”, p);
} return 0;
}

21
 The “for” loop
The “for” loop is just shorthand for this “while” loop structure.

float pow(float x, uint exp) float pow(float x, uint exp)

{ {
float result=1.0; float result=1.0;
int i; int i;
i=0; for (i=0; (i < exp); i++) {
while (i < exp) { result = result * x;
result = result * x; }
i++; return result;
} }
return result;
} int main(int argc, char **argv)
{
int main(int argc, char **argv) float p;
{ p = pow(10.0, 5);
float p; printf(“p = %f\n”, p);
p = pow(10.0, 5); return 0;
printf(“p = %f\n”, p); }
return 0;
}

22
Referencing Data from Other Scopes
So far, all of our examples all of the data values we have used have
been defined in our lexical scope

float pow(float x, uint exp)

{
float result=1.0;
int i;
for (i=0; (i < exp); i++) { Nothing in this scope
result = result * x;
}
return result;
}

int main(int argc, char **argv)

{
float p; Uses any of these variables
p = pow(10.0, 5);
printf(“p = %f\n”, p);
return 0;
}

23
Can a function modify its arguments?
What if we wanted to implement a function pow_assign() that
modified its argument, so that these are equivalent:
float p = 2.0; float p = 2.0;
/* p is 2.0 here */ /* p is 2.0 here */
p = pow(p, 5); pow_assign(p, 5);
/* p is 32.0 here */ /* p is 32.0 here */

Would this work?

void pow_assign(float x, uint exp)

{
float result=1.0;
int i;
for (i=0; (i < exp); i++) {
result = result * x;
}
x = result;
}

24
 NO!
Remember the stack!

void pow_assign(float x, uint exp)

{
float result=1.0; In C, all arguments are passed
int i;
for (i=0; (i < exp); i++) {
as values
result = result * x;
}
x = result;
} But, what if the argument is
{
the address of a variable?
float p=2.0;
pow_assign(p, 5);
}

float x 2.0
32.0
uint32_t exp 5
float result 1.0
32.0

float p 2.0 Grows

25
 Passing Addresses
Symbol Addr Value
Recall our model for variables stored in 0
memory 1
2
What if we had a way to find out the 3
address of a symbol, and a way to
char x 4 ‘H’ (72)
reference that memory location by
address? char y 5 ‘e’ (101)
6
address_of(y) == 5
memory_at[5] == 101 7
void f(address_of_char p)
8
{
memory_at[p] = memory_at[p] - 32;
9
} 10
char y = 101; /* y is 101 */ 11
f(address_of(y)); /* i.e. f(5) */
/* y is now 101-32 = 69 */ 12

26
 “Pointers”
This is exactly how “pointers” work.
A “pointer type”: pointer to char
“address of” or reference operator: &
“memory_at” or dereference operator: *

void f(address_of_char p) void f(char * p)

{ {
memory_at[p] = memory_at[p] - 32; *p = *p - 32;
} }

char y = 101; /* y is 101 */ char y = 101; /* y is 101 */

f(address_of(y)); /* i.e. f(5) */ f(&y); /* i.e. f(5) */
/* y is now 101-32 = 69 */ /* y is now 101-32 = 69 */

Pointers are used in C for many other purposes:

• Passing large objects without copying them
• Accessing dynamically allocated memory
• Referring to functions

27
 Pointer Validity
A Valid pointer is one that points to memory that your program controls.
Using invalid pointers will cause non-deterministic behavior, and will often
cause Linux to kill your process (SEGV or Segmentation Fault).
How should pointers be initialized?
There are two general causes for these errors:
• Program errors that set the pointer value to a strange number
• Use of a pointer that was at one time valid, but later became invalid

Will ptr be valid or invalid?

char * get_pointer()
{
char x=0;
return &x;
}

{
char * ptr = get_pointer();
*ptr = 12; /* valid? */
}

28
 Answer: Invalid!
A pointer to a variable allocated on the stack becomes invalid when that
variable goes out of scope and the stack frame is “popped”. The pointer will
point to an area of the memory that may later get reused and rewritten.

char * get_pointer()
{
char x=0;
return &x;
} But now, ptr points to a
{
location that’s no longer in use,
char * ptr = get_pointer(); and will be reused the next time
*ptr = 12; /* valid? */
other_function(); a function is called!
}

101 charaverage
int x 0 101
12
456603
Return

100 char * ptr 101

? Grows
29
 More on Types
We’ve seen a few types at this point: char, int, float, char *

Types are important because:

• They allow your program to impose logical structure on memory
• They help the compiler tell when you’re making a mistake

In the next slides we will discuss:

• How to create logical layouts of different types (structs)
• How to use arrays
• How to parse C type names (there is a logic to it!)
• How to create new types using typedef

30
 Structures Packing?
struct: a way to compose existing types into a structure

#include <sys/time.h> struct timeval is defined in this header

/* declare the struct */
struct my_struct { structs define a layout of typed fields
int counter;
float average;
struct timeval timestamp;
structs can contain other structs
uint in_use:1;
uint8_t data[0]; fields can specify specific bit widths
}; Why?

/* define an instance of my_struct */ A newly-defined structure is initialized using

struct my_struct x = {
in_use: 1, this syntax. All unset fields are 0.
timestamp: {
tv_sec: 200
}
};
x.counter = 1; Fields are accessed using ‘.’ notation.
x.average = sum / (float)(x.counter);

struct my_struct * ptr = &x; A pointer to a struct. Fields are accessed

ptr->counter = 2;
(*ptr).counter = 3; /* equiv. */
using ‘->’ notation, or (*ptr).counter

31
 Arrays
Arrays in C are composed of a particular type, laid out in memory in a
repeating pattern. Array elements are accessed by stepping forward in
memory from the base of the array by a multiple of the element size.

/* define an array of 10 chars */ Brackets specify the count of elements. Initial

char x[5] = {‘t’,’e’,’s’,’t’,’\0’};
values optionally set in braces.
/* accessing element 0 */
x[0] = ‘T’;
Arrays in C are 0-indexed (here, 0..9)
/* pointer arithmetic to get elt 3 */
char elt3 = *(x+3); /* x[3] */ x[3] == *(x+3) == ‘t’ (NOT ‘s’!)
/* x[0] evaluates to the first element;
* x evaluates to the address of the What’s the difference Symbol Addr Value
* first element, or &(x[0]) */ between char x[] and
char *x? char x [0] 100 ‘t’
/* 0-indexed for loop idiom */
#define COUNT 10 char x [1] 101 ‘e’
char y[COUNT]; For loop that iterates from char x [2] 102 ‘s’
int i;
for (i=0; i<COUNT; i++) { 0 to COUNT-1. char x [3] 103 ‘t’
/* process y[i] */ Memorize it!
printf(“%c\n”, y[i]); char x [4] 104 ‘\0’
}

32
 How to Parse and Define C Types
At this point we have seen a few basic types, arrays, pointer types, and
structures. So far we’ve glossed over how types are named.
int x; /* int; */ typedef int T;
int *x; /* pointer to int; */ typedef int *T;
int x[10]; /* array of ints; */ typedef int T[10];
typedef defines a
int *x[10]; /* array of pointers to int; */ typedef int *T[10]; new type
int (*x)[10]; /* pointer to array of ints; */ typedef int (*T)[10];

C type names are parsed by starting at the type name and working outwards
according to the rules of precedence:

x is
an array of
pointers to
int *x[10]; int Arrays are the primary source of
confusion. When in doubt, use
x is extra parens to clarify the
int (*x)[10];
a pointer to expression.
an array of
int

33
 Function Types
The other confusing form is the function type.
For example, qsort: (a sort function in the standard library)
void qsort(void *base, size_t nmemb, size_t size, The last argument is a
int (*compar)(const void *, const void *));
comparison function
/* function matching this type: */
int cmp_function(const void *x, const void *y);
const means the function is
/* typedef defining this type: */ not allowed to modify
typedef int (*cmp_type) (const void *, const void *); memory via this pointer.
/* rewrite qsort prototype using our typedef */
void qsort(void *base, size_t nmemb, size_t size, cmp_type compar);

size_t is an unsigned int

void * is a pointer to memory of unknown type.

34
 Dynamic Memory Allocation
So far all of our examples have allocated variables statically by defining them
in our program. This allocates them in the stack.

But, what if we want to allocate variables based on user input or other

dynamic inputs, at run-time? This requires dynamic allocation.

sizeof() reports the size of a type in bytes For details:

int * alloc_ints(size_t requested_count) $ man calloc
{ calloc() allocates memory for N
int * big_array;
big_array = (int *)calloc(requested_count, sizeof(int));
elements of size k
if (big_array == NULL) {
printf(“can’t allocate %d ints: %m\n”, requested_count); Returns NULL if can’t alloc
return NULL;
} %m ? Emstar tips

/* now big_array[0] .. big_array[requested_count-1] are It’s OK to return this pointer. It

* valid and zeroed. */
return big_array; will remain valid until it is
} freed with free()

35
 Caveats with Dynamic Memory
Dynamic memory is useful. But it has several caveats:

Whereas the stack is automatically reclaimed, dynamic allocations must be

tracked and free()’d when they are no longer needed. With every allocation, be
sure to plan how that memory will get freed. Losing track of memory is called a
“memory leak”. Reference counting

Whereas the compiler enforces that reclaimed stack space can no longer be
reached, it is easy to accidentally keep a pointer to dynamic memory that has
been freed. Whenever you free memory you must be certain that you will not try
to use it again. It is safest to erase any pointers to it.

Because dynamic memory always uses pointers, there is generally no way for the
compiler to statically verify usage of dynamic memory. This means that errors
that are detectable with static allocation are not with dynamic

36
 Some Common Errors and Hints
sizeof() can take a variable reference in place of a type name. This gurantees the right allocation,
but don’t accidentally allocate the sizeof() the pointer instead of the object!

/* allocating a struct with malloc() */ malloc() allocates n bytes

struct my_struct *s = NULL;
s = (struct my_struct *)malloc(sizeof(*s)); /* NOT sizeof(s)!! */
if (s == NULL) { Why?
printf(stderr, “no memory!”); Always check for NULL.. Even if you just exit(1).
exit(1);
}
malloc() does not zero the memory, so
memset(s, 0, sizeof(*s)); you should memset() it to 0.
/* another way to initialize an alloc’d structure: */
struct my_struct init = {
counter: 1,
average: 2.5,
in_use: 1
};

/* memmove(dst, src, size) (note, arg order like assignment) */

memmove(s, &init, sizeof(init));
memmove is preferred because it is safe
/* when you are done with it, free it! */ for shifting buffers
free(s); Why?
s = NULL;
Use pointers as implied in-use flags!
37
 Macros
Macros can be a useful way to customize your interface to C and make your
code easier to read and less redundant. However, when possible, use a static
inline function instead. What’s the difference between a
macro and a static inline function?

Macros and static inline functions must be included in any file that uses
them, usually via a header file. Common uses for macros:
More on C
/* Macros are used to define constants */ constants?
#define FUDGE_FACTOR 45.6 Float constants must have a decimal
#define MSEC_PER_SEC 1000 point, else they are type int
#define INPUT_FILENAME “my_input_file”
enums
/* Macros are used to do constant arithmetic */
Why?
#define TIMER_VAL (2*MSEC_PER_SEC) Put expressions in parens.
/* Macros are used to capture information from the compiler */
#define DBG(args...) \
do { \ Multi-line macros need \
fprintf(stderr, “%s:%s:%d: “, \
__FUNCTION__, __FILE__, __LINENO__); \ args… grabs rest of args
fprintf(stderr, args...); \
} while (0) Why?
Enclose multi-statement macros in do{}while(0)
/* ex. DBG(“error: %d”, errno); */
38
 Macros and Readability
Sometimes macros can be used to improve code readability… but make sure
what’s going on is obvious.
/* often best to define these types of macro right where they are used */
#define CASE(str) if (strncasecmp(arg, str, strlen(str)) == 0)

void parse_command(char *arg)

void parse_command(char *arg)
{
{
CASE(“help”) {
if (strncasecmp(arg, “help”, strlen(“help”)) {
/* print help */
/* print help */
}
}
CASE(“quit”) {
if (strncasecmp(arg, “quit”, strlen(“quit”)) {
exit(0);
exit(0);
}
}
}
}
/* and un-define them after use */
#undef CASE

Macros can be used to generate static inline functions. This is like a C version
of a C++ template. See emstar/libmisc/include/queue.h for an example of
this technique.

39
 Using “goto”
Some schools of thought frown upon goto, but goto has its place. A good
philosophy is, always write code in the most expressive and clear way
possible. If that involves using goto, then goto is not bad.

An example is jumping to an error case from inside complex logic. The

alternative is deeply nested and confusing “if” statements, which are hard to
read, maintain, and verify. Often additional logic and state variables must be
added, just to avoid goto.

goto try_again;
goto fail;

40
 Unrolling a Failed Initialization
{
using goto
state_t *initialize()
state_t *initialize()
/* allocate state struct */ {
state_t *s = g_new0(state_t, 1); /* allocate state struct */
if (s) { state_t *s = g_new0(state_t, 1);
/* allocate sub-structure */ if (s == NULL) goto free0;
s->sub = g_new0(sub_t, 1);
if (s->sub) { /* allocate sub-structure */
/* open file */ s->sub = g_new0(sub_t, 1);
s->sub->fd = if (s->sub == NULL) goto free1;
open(“/dev/null”, O_RDONLY);
if (s->sub->fd >= 0) { /* open file */
/* success! */ s->sub->fd =
} open(“/dev/null”, O_RDONLY);
else { if (s->sub->fd < 0) goto free2;
free(s->sub);
free(s); /* success! */
s = NULL; return s;
}
} free2:
else { free(s->sub);
/* failed! */ free1:
free(s); free(s);
s = NULL; free0:
} return NULL;
} }
return s;
}

41
 High Level Question: Why is
Software Hard?
Answer(s):
• Complexity: Every conditional (“if”) doubles
number of paths through your code, every
bit of state doubles possible states
– Solution: reuse code paths, avoid duplicate state variables

• Mutability: Software is easy to change..

Great for rapid fixes .. And rapid breakage
.. always one character away from a bug
– Solution: tidy, readable code, easy to understand by inspection.
Avoid code duplication; physically the same  logically the same
42
 Addressing Complexity
• Complexity: Every conditional (“if”) doubles number of paths through
your code, every bit of state doubles possible states
– Solution: reuse code paths, avoid duplicate state variables

reuse code paths

On receive_packet:
if queue full, drop packet
else push packet, call run_queue On input, change our state as needed, and call
On transmit_complete:
Run_queue. In all cases, Run_queue handles
state=idle, call run_queue taking the next step…
Run_queue:
if state==idle && !queue empty
pop packet off queue
start transmit, state = busy

43
 Addressing Complexity
• Complexity: Every conditional (“if”) doubles number of paths through
your code, every bit of state doubles possible states
– Solution: reuse code paths, avoid duplicate state variables

avoid duplicate state variables

int transmit_busy; msg_t *packet_on_deck;
msg_t *packet_on_deck;
int start_transmit(msg_t *packet)
int start_transmit(msg_t *packet) {
{ if (packet_on_deck != NULL) return -1;
if (transmit_busy) return -1;
/* start transmit */
/* start transmit */ packet_on_deck = packet;
packet_on_deck = packet;
transmit_busy = 1; /* ... */
return 0;
/* ... */ }
return 0;
} Why return -1?

44
 Addressing Mutability
• Mutability: Software is easy to change.. Great for rapid fixes .. And
rapid breakage .. always one character away from a bug
– Solution: tidy, readable code, easy to understand by inspection.
Avoid code duplication; physically the same  logically the same

Tidy code.. Indenting, good formatting, comments, meaningful variable and

function names. Version control.. Learn how to use CVS

Avoid duplication of anything that’s logically identical.

struct pkt_hdr {
int source; struct pkt_hdr {
int dest; int source;
int length; int dest; Otherwise when one
}; int length;
struct pkt { };
changes, you have to
int source; struct pkt { find and fix all the
int dest; struct pkt_hdr hdr;
int length; uint8_t payload[100];
other places
uint8_t payload[100]; };
};

45
Solutions to the pow() challenge
Recursive
questionIterative

float pow(float x, uint exp)

{
float result; float pow(float x, uint exp)
{
/* base case */ float result = 1.0;
if (exp == 0)
return 1.0; int bit;
for (bit = sizeof(exp)*8-1;
/* x^(2*a) == x^a * x^a */ bit >= 0; bit--) {
result = pow(x, exp >> 1); result *= result;
result = result * result; if (exp & (1 << bit))
result *= x;
/* x^(2*a+1) == x^(2*a) * x */ }
if (exp & 1)
result = result * x; return result;
}
return result;
}

Which is better? Why?

46