Detailed learning objectives are addressed in the Accredited Symbian Developer Primer.
Read what others have said about the ASD exam.
ASD Curriculum V1 (2005-2006)
The following topic list constitutes the Principles of Symbian OS curriculum. A full set of supporting course materials, broken down into topic-based modules, is available for universities. Please contact Symbian Academy for further details.
The questions contained within the Accredited Symbian Developer examination are derived from the Principles of Symbian OS curriculum. Any course adhering to the curriculum will therefore prepare a student to become an Accredited Symbian Developer.
- C++ Basics
- C++ Overloading and Polymorphism
- C++ Inheritance and Access Control
- C++ Templates
- C++ Classes
- Symbian OS Types & Declarations
- Descriptors
- Active Objects
- Tool Chain
- Object Construction
- Cleanup Stack
- System Structure
- Dynamic Arrays
- File Server, Stores and Streams
- Client Server
- Sockets
- Binary Compatibility
- DBMS
1. C++ Basics
Evaluates the basic understanding of writing a C++ program and the concepts underlying object orientation and reuse. Know the properties of the declaration and definition statements.
Summary
These objectives deal with the language basics: statements, expressions, types, declarations and definitions. Some very
basic object-oriented theory is covered, but the focus is on a thorough understanding of the language basics.
Objectives
1.1 Understand the use of the new and delete expressions (including array[ ] form)
1.2 Be able to describe the C++ Preprocessor purpose and common directives
1.3 Understand that user-defined types require explicit conversion functions
1.4 Specify the syntax and meaning of unary and binary operator expressions
1.5 Understand the use and properties of the C++ reference operator
1.6 Specify what the compiler automatically generates for user-defined classes
1.7 Specify the syntax and behavior of C++ conditional statements
1.8 Understand the purpose, syntax and behavior of C++ loop statements
1.9 Understand the role inline functions play in C++
1.10 Recognize typedef as a synonyms for an existing type
1.11 Specify the attributes of a C++ object with respect to object-oriented programming
1.12 Understand the function of the tools in the C++ toolchain
2. C++ Overloading and Polymorphism
Assesses knowledge of the overloading of C++ functions and operators and determines proficiency in implementing polymorphism with the use of virtual functions.
Summary
These objectives cover implementation and overhead considerations when using overloading along with OOP theory and
use of virtual methods to implement dynamic polymorphism.
Objectives
2.1 Understand the rules and pattern matching criteria for correct overloaded function invocation.
2.2 Identify the typical uses and behavior for operator overloading
2.3 Specify the required function members needed to support safe member pointer data ownership
2.4 Be to able to state C++ support for dynamic polymorphism
2.5 Specify the use of virtual functions and their implementation trade-offs
2.6 Describe the purpose of the “virtual table” citing constraints and overheads.
2.7 Understand how an abstract base class is defined in C++
2.8 Cite the implementation requirements to support the static_cast operator in user-defined classes
2.9 The rules for passing default arguments and an unspecified number of arguments to a function.
2.10 Understand the use of overriding to modify behavior in a derived base class inheritance
2.11 Recognize implicit constructor invocation and the role the explicit keyword plays
3. C++ Inheritance and Access Control
Measures understanding of methods for protecting class members from the outside world, while giving access to preferred code. Also assesses the user's knowledge on the use of inheritance in C++ as a tool for reuse, extension, and substitution of C++ code.
Summary
C++ provides well defined access control rules for inheritance and class users, these objectives cover the behavior of
these rules including:
Access specifiers and scope
Inheritance relationships and association
Implementation and behavior
The purposes and benefits of OOP inheritance
Objectives
3.1 Understand the scope resolution operator (::) syntax for access base-derived class hierarchy
3.2 Describe the scope access rules and purpose for public, protected and private inheritance
3.3 Understand the key benefits and purpose of inheritance
3.4 Cite the object-oriented relationship for inheritance
3.5 Describe what private, protected and public access control for class members
3.6 Understand the scope rules and syntax of friend functions
3.7 Specify the correct invocation order of constructors in a base-derived hierarchy
3.8 Cite the scope access rules and lifetime of a nested class
3.9 Understand the rules for static class data and function members
4. C++ Templates
Checks basic understanding of function and class templates in C++.
Summary
Although Symbian C++ currently only uses Thin Templates, the ASD candidate is expected to understand the syntax and
use of C++ function and class templates. As well as declaration and definition syntax, template inheritance and
specialization is also covered.
Objectives
4.1 Specify the syntax for a simple function template specialization
4.2 Be able to cite the use and advantages of function templates over macros
4.3 Understand the syntax and semantics of a template type/class declaration
4.4 Understand how templates are used for generic programming and the advantages thereof
4.5 Understand the inheritance mechanisms and syntax supported by class templates
4.6 Broadly understand the compiler and linker errors associated with templates
4.7 Recognize the prototype declaration and pattern matching properties of a template declaration and its use
4.8 Define and explain the development requirements for a typical smart pointer implementation
5. C++ Classes
Tests proficiency in creating and using user-defined classes with associated behavior.
Summary
These objectives focus on the implementation details of C++ OOP support, covering scope, life-span, basic
encapsulation, and syntax of C++ classes.
Objectives
5.1 Specify the properties of static class members
5.2 Specify the purpose and use of a copy constructors
5.3 Be able to declare and specify the syntax for pointers to class members
5.4 Identifying nested classes and their scope and life-span
5.5 Differentiate between basic data structures and classes.
5.6 Specify the mechanisms of OO reuse available in C++
5.7 Understand the order of deletion in a derived-bass class inheritance, including class object members.
5.8 The use of inline in class declarations.
6. Symbian OS Types and Declarations
Ensures that the candidate understands the fundamental Symbian OS types, naming conventions and coding style, and the usage paradigms of each basic type of Symbian OS class.
Summary
The following objectives cover the Symbian OS class naming conventions, usage and behavior.
Objectives
6.1 Know how to identify and use the fundamental Symbian OS types (e.g. TBool, TInt) and understand that they
replace use of all primitive C++ types (bool, int) except void when used as a function return value
6.2 Recognize the attributes of Symbian OS T classes
6.3 Understand the behavior and properties of Symbian OS C classes
6.4 Recognize the use and attributes of Symbian OS R classes
6.5 Recognize the use and attributes of Symbian OS M classes
6.6 Recognize the attributes of static Symbian OS classes
6.7 Know which factors to consider when creating a Symbian OS class
6.8 Understand why the Symbian OS naming convention is important
7. Descriptors
Test the understanding of the motivation for using descriptors, how to use buffer and pointer descriptors and when to use package descriptor classes.
Summary
The following objectives cover the characteristics of the Symbian OS descriptor classes including memory management, inheritance hierarchy, use as function parameters, conversion methods and key aspects of the API.
Objectives
7.1 Know the characteristics of descriptors (i.e. they may contain text or binary data, they may be 8 or 16 bit or
expressed as neutral (which is 16 bit since Symbian OS is built for Unicode) and they do not dynamically extend the data
they reference, so will panic if calculated to be of insufficient size to store data resulting from a method call.
7.2 Know the characteristics of the TDesC, TDes, TBufC, TBuf, TPtrC, TPtr and HBufC descriptor classes such as
their inheritance hierarchy, memory layout, data mutability)
7.3 Understand the memory efficiency of the descriptor class inheritance model and its implications
7.4 Understand that the descriptor base classes (TDesC and TDes) implement all generic descriptor manipulation
code but cannot be instantiated. Derived descriptor classes merely add construction and assignment code specific to
their type)
7.5 Identify the correct and incorrect use of modifier methods in the TDesC and TDes classes.
7.6 Understand the difference between Size(), Length() and MaxLength() descriptor methods
7.7 Understand the difference between Copy() and Set() descriptor methods and how to use assignment correctly.
7.8 Understand the correct way to specify a descriptor as a function parameter (always by reference with a lifetime at
least that taken by the function to complete), both for passing constant data (const TDesC(8)&) and receiving data written
into it by the function (TDes(8)&)
7.9 Know that the TFileName type should not be used indiscriminately because of the stack space it consumes
7.10 Know how to manipulate literal descriptors and know that those specified using _L are deprecated
7.11 Specify the difference between literal descriptors using _L and those using _LIT and the disadvantages of using
the former
7.12 Know how to convert 8 bit descriptors into 16 bit descriptors and vice versa using the descriptor Copy() method or CnvUtfConverter class. Recognize how to read data from file into an 8 bit descriptor and ‘then translate’ the data to 16 bit
without padding.
7.13 Identify the correct techniques and methods to construct a heap buffer.
8. Active Objects
Tests understanding of why Active Objects are preferred over Threads and under what conditions, the use and implementation of simple Active Objects and their relation to the Active Scheduler.
Summary
The following objectives cover the use of active objects for non-preemptive event handling on Symbian OS including: how
to derive an active object class (priority assignment and virtual overrides, and their characteristics), “conditions of use”,
common errors (bad practice) and the role of the active scheduler.
Objectives
8.1 Recognize the typical uses of active objects (e.g. to allow asynchronous tasks to be requested without blocking a
thread or to complete long-running tasks)
8.2 Know the inheritance characteristics of active objects (all derive from CActive, implement RunL() and DoCancel()
and RunError if a leave may occur in RunL())
8.3 Understand the role of the active scheduler, its characteristics, to call Start() on it when at least one active object
has an outstanding request, and reasons why CActiveScheduler may be derived
8.4 Understand the difference between multi-tasking using multiple threads and multiple active objects, and the reason
why the latter is preferred in Symbian OS code
8.5 Recognize that the active object event handler method (RunL()) is non-preemptive
8.6 Understand the “conditions of use” when implementing an active object (e.g. setting priority in the constructor,
adding to the active scheduler, calling SetActive() when submitting an asynchronous request (but only if the object is not
already set active), submitting only one asynchronous request at a time, keeping RunL() timely, calling Cancel() in the
destructor, not overloading Cancel())
8.7 Understand the different paths in code that the active object uses when an asynchronous request completes as a
result of a call to Cancel() and as a result of normal completion
8.8 Know some of the possible causes of a stray signal panic
8.9 Understand how (and how not) to use an active object to carry out a long-running (or background) task and
demonstrate an understanding of how self-completion is implemented.
8.10 Recognize that a call to User::After() blocks a thread until the time specified as a parameter to after has elapsed
9. Tool Chain
Measures that the candidate has a practical working knowledge of the Symbian OS tool chain and development environment.
Summary
The following objectives cover an understanding of the mmp file syntax, use of bldmake, the role of resource files,
emulator settings, the difference between running code on emulator and hardware, the ABI binary standard and tool
specific errors (not programming errors).
Objectives
9.1 Know the difference between code size generated for an ARM or ARM build and that when building the same code
for THUMB
9.2 Understand when to invoke bldmake
9.3 Recognize differences between running code on the Windows emulator and on target hardware
9.4 Know typical mmp syntax (e.g. recognize standard targettypes)
9.5 Understand the purpose of the Symbian tool PETRAN/ELFTRAN
9.6 Know the basics of resource files including the output generated by the compiler (file extensions and typical
contents), resource file extension, typical use and the ability to use localization files for language variability)
10. Object Construction
Evaluates knowledge of 2-phase construction in Symbian OS, safely creating objects and avoiding memory leaks.
Summary
The following objectives test an understanding of the importance, implementation and reasons for 2 phase construction,
and how to ensure object destruction is efficient and safe.
Objectives
10.1 Know the reasons why code should not leave inside a constructor when instantiating CBase-derived objects on
Symbian OS and why 2-phase construction is used to avoid objects with undefined state
10.2 Recognize that constructors are given private or protected access specifiers in classes which use two-phase
construction
10.3 Understand that the overload of operator new which takes ELeave as a parameter means that the pointer return
value will always be valid if a leave has not occurred
10.4 Understand how to implement two-phase construction (and how to construct an object which derives from a class
also using a two-phase method of initialization)
10.5 Know that it is not efficient or necessary to set a pointer to NULL after deleting it in destructor code
10.6 Understand that a destructor must check before de-referencing a pointer but that it is not necessary to check if
simply calling delete on the pointer
11. Cleanup Stack
Demonstrates practical knowledge of the Cleanup Stack and the difference between standard C++ and Symbian OS in handling leaks and exceptions.
Summary
The following objectives cover the following idioms:
Symbian OS leaves vs. standard C++ exception support
Cleanup stack
TRAP handlers
Objectives
11.1 Know that, pre v9, Symbian OS does not support standard C++ exceptions (try/catch/throw) but uses a lightweight alternative TRAP/leave.
11.2 Understand that leaves are like the setjmp/longjmp declarations in C, allowing code to jump from a point where an
error or exception occurs to a place in code where it can be handled
11.3 Know that leaves are a fundamental part of Symbian error handling and used throughout the system, indicated by
use of a trailing L suffix on functions containing code which may leave
11.4 Recognize the typical conditions which cause a leave and those which are not (e.g. programming errors, directing
code logic)
11.5 Understand that leaves are used for error handling and code should very rarely return an error and leave
11.6 Recognize the characteristics of a TRAP handler (such as potential runtime inefficiencies through overuse)
11.7 Recognize that it is incorrect for objects to remain on the cleanup stack when code exits a TRAP handler
11.8 Know how to use the cleanup stack to make a function leave safe, so memory is not leaked in the event of a leave.
Be able to spot functions which are not leave safe
11.9 Know how to use CleanupStack::PushL() and CleanupXPushL() (X = Close, Delete or Release) for objects of C, R,
M and T classes and CleanupArrayDeletePushL for C++ arrays
11.10 Understand that CleanupStack::PushL() will not leak memory even if it itself leaves
11.11 Understand how to remove items from the cleanup stack in terms of the order they may be removed and how to
destroy them most efficiently (if required) using PopAndDestroy() or simply transfer ownership using Pop()
11.12 Recognize correct and incorrect use of the cleanup stack
11.13 Understand the consequences of putting a C class on the cleanup stack if it does not derive from CBase
11.14 Recognize the use of the __UHEAP_MARK and __UHEAP_MARKEND macros to detect memory leaks
11.15 Understand the meaning of the Symbian OS function suffixes L, C and D
11.16 Recognize the typical system functions which may or will cause a leave (User::Leave, User::LeaveIfError, new
(ELeave)) and how to use them
11.17 Understand the difference between a leave and a panic
12. System Structure
Tests knowledge of the underlying structure of the Symbian OS, including threads, processes, DLLs and memory management. Also assesses the candidates understanding of common system components.
Summary
The following objectives cover the following:
writable static data
UIDs
threads and processes
memory management idioms
system architecture including non-functional requirements
IPC (preferred mechanisms on Symbian OS)
recognizers
synchronization primitives
defensive programming
debugging techniques
Objectives
12.1 Know and understand the characteristics of polymorphic interface and static DLLs
12.2 Recognize basic porting strategies to remove the use of writable static data in DLLs
12.3 Know the purpose of Symbian OS UIDs, their type, the UID2 values for static and polymorphic DLLs, how to
specify UIDs in MMP files, and their use in DLLs and exes
12.4 Recognize the correctness of basic statements about Symbian OS memory management (ROM execution,
ROM/RAM execution speed, writable static data, data segments, virtual addressing)
12.5 Recognize the correctness of basic statements about threads and processes on Symbian OS
12.6 Recognize basic statements about Symbian OS (be able to pick out multi-tasking, 32-bit, used by multiple
manufacturers and supporting several UI platforms)
12.7 Know that Symbian OS does not allow library lookup by name but only by ordinal
12.8 Recognize the preferred mechanisms for IPC on Symbian OS (client-sever, publish and subscribe, message
queues and shared buffer I/O) and demonstrate awareness of which mechanism is most appropriate for a number of
given scenarios both on realtime and non-realtime versions of Symbian OS.
12.9 Recognize correct statements about the role of Recognizers in Symbian OS
12.10 Recognize the role and the characteristics of the synchronization primitives RMutex, RCriticalSection and
RSemaphore
12.11 Know the type of parameters to pass to User::Panic and understand how to make them meaningful
12.12 Understand the use of __ASSERT_DEBUG statements to detect programming errors in debug code by breaking
the flow of code execution using a panic.
12.13 Recognize that __ASSERT_ALWAYS should be used more sparingly because it will test statements in released
code too.
13. Dynamic Arrays
Measures proficiency in the use of Symbian OS dynamic arrays in preference to standard C++ arrays, and the choice of dynamic array class depending on desired usage and characteristics of array elements.
Summary
The following objectives cover an understanding of the Symbian OS dynamic array classes including their practical
application, memory layout and expansion strategy (granularity).
Objectives
13.1 Demonstrate an understanding of the basics of Symbian OS dynamic arrays (both RArray-derived and CArray-derived) e.g. they can be stack or heap based, can be sorted, are searched from the first index onwards, can be used
both user and kernel side
13.2 Understand the different types of Symbian OS dynamic arrays i.e. how the memory for the array is managed (flat
or segmented), how the objects are stored (in the array or elsewhere with pointers managed by the array), whether they
are owned and destroyed by the array, and whether the object lengths are fixed or variable
13.3 Recognize the use cases of an array which make it preferable to use a segmented buffer array class rather than a
flat array class and the advantages/disadvantages of each type of array
13.4 Understanding the meaning of array granularity
13.5 Demonstrate an understanding of how to sort dynamic arrays
13.6 Know the reasons for preferring to use RArrayX to CArrayX, and the exceptional cases where CArrayX classes are
a better choice
14. File Server and Streams
Identifies understanding of the use of files, stores and streams for storing persistent and temporary data. Also measures whether the candidate has knowledge of the conditions and intended usage which determine the different classes to use for storing data.
Summary
The following objectives cover the following:
RFile API methods
RFs API methods
Stream operators
Stream and store classes and their use to manipulate large documents
Difference between use of RFile and stream classes and reasons for preferring each
Objectives
14.1 Know the characteristics of the RFile API methods to open a file (Create(), Open(), Replace() and Temp())
14.2 Know that RFs::ReadFileSection() is a method which reads the specified number of bytes from a file *without*
opening it, so there is now way to prevent the contents of the file being accessed using the RFile::Open() methods with
EFileShareExclusive flag or similar
14.3 Know the basic functionality offered by class RFs including: file creation and deletion, retrieving file and directory
attributes, directory listings, filename parsing (using the session/default path), providing drive and volume information and
formatting, change notification, reading from a file without opening it, adding file system plug-ins
14.4 Recognize that the >> and << operators can leave
14.5 Be able to recognize the following as Symbian OS store and stream classes and know the basic characteristics of
each (e.g. base class, memory storage, persistence, modification etc) Store classes: CStreamStore, CPersistentStore,
CBufStore, CSecureStore, CEmbeddedStore, CFileStore, CPermanentFileStore, CDirectFileStore Stream classes:
RWrite/ReadStream, RFileWrite/ReadStream, RStoreWrite/ReadStream
14.6 Understand how to use ExternalizeL and operator<< with RWriteStream to write an object to a stream (and
equivalent for InternalizeL and operator>> to read it back)
14.7 Know the reasons why use of the stream APIs over use of RFile may be preferred
14.8 Understand how to use the stream and store classes to manage large documents most efficiently
15. Client / Server
Recognizes the use cases of the Client / Server model within a handset, system components utilizing the model and applies knowledge simple Server implementations.
Summary
The following objectives cover the following:
the role of client-server on Symbian OS
reasons for client-server
characteristics of the communication protocol
runtime impact and memory overheads
threading model
classes used by the client-server framework
server-side objects which must be created on start up (cleanup stack, active scheduler)
client-server data transfer mechanism, marshalling and data lifetime requirements
client subsessions
system and transient server
Objectives
15.1 Understand that the client-server framework is used (i) to separate system resources from code which uses them,
(ii) to manage concurrent access and protect the resource from potentially badly programmed or malicious usage and (iii)
can be used to allow access to a resource (such as the filesystem) by numerous different applications/processes
15.2 Recognize that the client-server framework is useful for implementing asynchronous services since the server
always runs in a separate thread to the clients
15.3 Understand the potential impact on runtime speed from using a client-server and differentiate between
circumstances where it is useful/necessary and where it is inefficient
15.4 Know the fundamentals of the Symbian OS client-server “pattern” such as: client and server are in different
threads (but not necessarily processes), the client makes a series of requests to the server - each identified by an
enumerator and with optional payload data, the client and server cannot directly read each others address space,
requests may be synchronous or asynchronous (only one synchronous request can be serviced at a time)
15.5 Understand the basics of client-server communication (the client-server communication channel is known as a
session, the number of sessions created by a client should be minimized because session creation carries a speed and
memory overhead - both client- and server-side, sessions are not reusable once they are closed, client sessions can be
shared between all threads in a client process if derived from the sharable session base class and sharing is allowed on
the handle, sessions are R classes, sessions can have up to 255 outstanding asynchronous requests at a time but only
one synchronous request)
15.6 Recognize the objects that a server must instantiate when it starts up (cleanup stack, active scheduler) and
recognize that an inactivity timer is optional since some servers are not transient
15.7 Know the classes used by the Symbian OS client-server framework and basic information about the role of each
(including CSecureServer and TPolicyServer for EKA2 content - for more advanced candidates)
15.8 Know the basics of how clients and a server transfer data for synchronous and asynchronous requests (e.g. for an
asynchronous call, the lifetime of any data transferred to the server must be at least that of the call itself, the client
passes up to 4 32-bit arguments to the server - which can include pointers to descriptors which the server reads/writes
using RThread)
16. Sockets
Evaluates the ability to add communication services to an application and handling asynchronous communication events with the socket server architecture.
Summary
The following y objectives cover practical usage of the RSocket API and RHostResolver class.
Objectives
16.1 Demonstrate a basic understanding of the use of sockets on Symbian OS
16.2 Recognize the sequence of calls necessary before it is possible to send or receive data over an unconnected or
datagram socket
16.3 Know which of the RSocket API methods can be used to make a socket wait asynchronously for a connection
16.4 Know which RSocket API methods should be used for an unconnected or datagram socket to receive data
16.5 Know which RSocket API method should be used for a connected or stream-interfaced socket to send data
16.6 Recognize the characteristics of the RSocketServ class (a client session with the socket server, a container for all
sockets used by the client, can be used to preload a PRT, cannot be used directly to send/receive data or establish
connections)
16.7 Know the characteristics of the RHostResolver class
16.8 Understand the role and purpose of Protocol Modules (PRTs) on Symbian OS
16.9 Demonstrate an understanding of the implementation of blocking and non-blocking sockets on Symbian OS
16.10 Recognize the characteristics of socket termination on Symbian OS
17. Binary Compatibility
Assesses understanding of binary compatibility and the programming and design techniques which are required to maintain binary compatibility in code modules and APIs.
Summary
The following objectives cover the following:
the definition of compatibility at different levels (binary, link, source, forwards and backwards)
what can’t be changed without breaking compatibility
what can be changed without breaking compatibility
best practice - designing to ensure compatibility is retained
Objectives
17.1 Recognize which attributes of a class are necessary in order that a change in the size of the class data will not
break compatibility
17.2 Understand which class-level changes will break source compatibility, and which will not
17.3 Understand which class-level changes will break binary compatibility and which will not
17.4 Understand which library-level changes will break binary compatibility and which will not (e.g. the impact of
changing ordinal numbers by re-freezing a class after adding new exports unless it is carefully managed)
17.5 Understand which function-level changes will break binary and source compatibility and which will not
17.6 Differentiate between derivable and non-derivable C++ classes in terms of what can be changed without breaking
binary compatibility
17.7 Recognize the coupling arising from the use of inline functions and differentiate between cases where it will make
maintaining binary compatibility more difficult and where it will be less significant
17.8 Recognize best practice for maintaining source and binary compatibility
18. DBMS
Aims to test knowledge of implementation of engine services using DBMS and common manipulation and access functions of Symbian OS databases.
Summary
The following objectives cover an understanding of the DBMS architecture, class hierarchy, database query API calls
(including SQL interfaces), transaction strategies (locks and sharing) and manipulation of returned data.
Objectives
18.1 Recognize valid ways of accessing DBMS on Symbian OS
18.2 Be able to match given scenarios with the most appropriate DBMS access type
18.3 Recognize the classes which derive from the base DBMS class RDbDatabase and how they are specialized
18.4 Recognize which member functions of RDbDatabase are valid, and which are not, when testing, processing and
instigating database transactions and locks
18.5 Recognize DBMS classes which can be instantiated and used by a client to manipulate database data
18.6 Understand how to use RDbNotifier to receive notification of changes and access to a database
18.7 Understand the differences between the native DBMS APIs and the SQL interfaces provided
18.8 Know the RDbDatabase API method to call when executing a SQL query which generates a table
18.9 Know which RDbView API method to call to execute a SQL query which generates the view specified on an
RDbDatabase parameter
18.10 Know which methods can be used to make a column auto-incrementing in a table definition