Object - Dev. - Testing

Objective
To provide the knowledge and skills required to explain the terms and concepts of object technology and to make effective use of these in software projects.

Target audience
Project managers, executives, analysts, designers and software developers.

Prerequisites
Good knowledge of computer science.

Topics covered

• Concepts: objects, classes, instances, methods, encapsulation, inheritance, polymorphism (problems, advantages and examples presented with each concept)
• Traditional vs. object-oriented approach
• Principles of object-oriented analysis and design
• Object-oriented languages and environments: C++, Java and C# (origin, objectives, main characteristics and uses) and more (VB6, VB.NET, Delphi, Smalltalk Perl, Python, PHP, Ruby, etc)
• Re-use: internal, external, costs, orientations and libraries of components
• Object-oriented methodologies: development phases and processes, CRC, Booch, OMT, Jacobson and UML
• Business Process Modeling (BPM), the n-tier model, Web Services, SOA architecture, client-server, rich and thin clients
• Standards: COM, .NET, Beans, J2EE, OMG, ODMG, IDL, ODL, XML, SQL, OQL CORBA, RMI and SOAP
• Advantages and disadvantages of the object-oriented approach
• Simplified object-oriented processes and managing object-oriented projects

Objective
To provide the knowledge and skills required to analyze and use Design Patterns, standardized design solutions for recurring problems. Design patterns are considered to be one of the most important object-oriented techniques and strategies.

Target audience
Designers and software developers.

Prerequisites
Knowledge of object-oriented concepts (Course DE101) and of UML notation (Course DE102).

Topics covered

• Essential elements, catalog, space, and format of design patterns
• Design strategies and techniques and reuse mechanisms
• Creational patterns: Abstract factory, Builder, Factory method, Prototype and Singleton
• Structural patterns (composition of objects to obtain new software functionality, identification of abstract or extendable class structures): Adapter, Bridge, Composite, Decorator, Facade, Flyweight and Proxy
• Behavioural patterns (extendable and decoupled collaborations): Chain of responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template method and Visitor
• Practical techniques used to select and apply patterns
• Steps involved in producing a pattern

Note: Solutions presented are in UML and include concrete examples.

Objective
To provide the knowledge and skills required to recognize the key features of Service Oriented Architecture, and to understand the principles and the best practices used to build more flexible architectures.

Target audience
IT directors, project leaders, managers, architects, analysts and designers.

Prerequisites
Good knowledge of computer science.

Topics covered

• Fundamental concepts related to objects and components
• Basic definitions, presentation of case studies
• The key concepts and principal characteristics of a SOA
• Clarification of some misconceptions regarding SOA
• Problems which hamper the adoption and governance of SOA
• The evolution of SOA: from XML to Web Services
• Comparing SOA to earlier architectures (client-server, Internet, distributed)
• SOA with a Web Services framework: service description (WSDL) and messaging (SOAP)
• Service oriented principles within the business
• Service layers: abstraction, application, business, coordination, configuration
• Development and delivery strategies: top-down, bottom-up and agile
• Introduction to service oriented analysis and design
• Implementation platforms (basic, J2EE, .NET) and integration issues
• Concluding case studies

Accredited course.
6 PDU

Objective
To provide the knowledge and skills required to use UML notation, the industry standard for documenting and communicating the analysis and design of an object-oriented project.

Target audience
Analysts, designers and software developers involved in object-oriented application development.

Prerequisites
Knowledge of object-oriented concepts (Course DE101).

Topics covered

• Fundamentals of objects, the goals and impacts of using UML in development
• Static models: class diagrams, classes, associations, aggregations, properties, stereotypes, etc.
• Operational models: pre-conditions, post-conditions and invariants
• Dynamic models: sequence, collaboration, state and activity diagrams
• Establishing requirements: actors, use cases, dictionary, the concept model and scenarios
• Analysis (packages and class specifications) and design (architecture definition, component and deployment diagrams)
• Introduction to Design Patterns
• Implementation: rules for translating models into an object-oriented language
• Perspectives and best practices regarding the use of UML diagrams
• Case studies and exercises
• Guidelines and practical advice

Objective
To provide the knowledge and skills required to understand the concepts, models, notation, light-weight agile processes, strategies, and best practices commonly used in object-oriented development projects.

Target audience
Managers, project managers and designers.

Prerequisites
Knowledge of computer science.

Topics covered

• Review of object-oriented concepts and the idea of components
• The promise of object-oriented technology
• Traditional unified and object-oriented development: processes, notation, cycles, phases and techniques
• The history of light-weight development systems in the world
• From fragility to agility: basic principles and best practices in the industry
• Introduction to the main concepts and goals of Agile methods: eXtreme Programming and Scrum
• Selecting and integrating simple and practical development strategies inspired by Agile methodologies
• Examples, workshops and case studies

Accredited course.
12 PDU

Objective
To provide the knowledge and skills required to implement a test-driven development methodology and to automate unit and integration tests.

Target audience
Software developers.

Prerequisites
Practical experience with one of the following programming languages: C++ (Course MN202), C# (Course MN201 or Course MN203), VB.NET (Course MN204) or Java (Course DE204).

Topics covered

• Introduction to Agile Test-Driven Development (TDD)
• Using test frameworks for object-oriented languages: NUnit (VB.NET, C#, and J#), JUnit (Java), CUnit (C++), DUnit (Delphi) and Fit (integration tests)
• Presentation of a proven approach for unit tests: when, what, and how to test
• Organization, construction, initiation and scheduling of test cases and test suites
• Implementation of a unit test context via decoupling techniques based on interfaces and abstract classes
• Test Patterns: phases, double, mock, stubs and organization
• Presentation of best practices in writing unit tests and unit integration: fine granularity analysis, minimization of bugs, non-regression of code, improved robustness of applications and efficient documentation

Objective
To provide the knowledge and skills required to implemented a test-driven development (TDD) methodology for embedded applications, whether for the host or the target.

Target audience
Developers.

Prerequisites
Experience with the C programming language. Experience with B# (Course DE122) or C# (Course MN201) is an advantage.

Topics covered

• Introduction to Test-Driven Development (TDD) with Agile methodology
• Using the BSharpUnit testing framework with the languages C, B# and C#
• Survey of a proven approach for managing unit tests: when, what and how to test
• Organization, creation, launching and frequency of test cases and test suites
• Setting up test contexts by severing dependencies and introducing interface classes
• Tracking, test patterns, mock objects, roadmaps
• Strategies for automating testing on host and target machines
• Emulation, instrumentation and tracing peripherals on the host station via performance counters and threads
• Presentation of best practices in writing unit tests and integration tests in order to improve the reliability of embedded application

Objective
To provide the knowledge and skills required to apply the Scrum agile methodology in software development, emphasizing iterative development, incremental processes and collaboration based on a two to four week work cycle.

Target audience
Managers, project leaders, designers, analysts and developers.

Prerequisites
Good knowledge of software development.

Topics covered

• Basic principles of Scrum
• Light and agile software development facilitated by simplified structures and processes
• Brief comparison with unified processes
• Roles in a Scrum team
• Frequently asked questions about Scrum and Agile
• The prioritized list of requirements, and how to document them
• Planning a cycle (sprint): preparation, agenda, duration, goals and scenarios (stories)
• Revision meetings and daily meetings: format, strategies, advice, warnings and retrospectives
• Estimation techniques based on calculating the cruising speed for a team
• Combining Scrum with test-driven development, and the role of acceptance tests

Objective
To provide the knowledge and skills required to place the requirements gathering phase within the (unified and agile) software development process as well as to identify, estimate and plan requirements with the help of use cases and user stories.

Target audience
Project leaders, business analysts, functional analysts and developers.

Prerequisites
Good knowledge of computer science.

Topics covered

• Getting started: interactive and incremental processes, phases, activities, iterations, initial description of a project, and risk analysis
• Identification of the system scope, elements, and generalization and collaboration relationships with use case models
• Categorization of functional/nonfunctional requirements and their prioritization
• Effectively describing the roles of the actors and the functionality of a use case and a user story
• Fundamental use cases, preconditions, postconditions, scenarios, branching, iteration, and basic, alternative and exceptional event flows
• Principal features of use cases and user stories, as well as pitfalls to avoid
• Examples of formats used for use cases and user stories, drawn from actual projects
• A checklist for verifying and integrating with unified and agile development processes: RUP, XP and Scrum
• User stories and the agile methodology: preparation, estimation and planning

Objective
To provide the knowledge and skills required to apply the best class design practices available in the industry, and to improve software structure, legibility, maintainability and enhancibility.

Target audience
Software developers.

Prerequisites
Practical experience with one of the following programming languages: C++ (Course MN202), C# (Course MN201 or Course MN203), VB.NET (Course MN204) or Java (Course DE204).

Topics covered

• Ways of improving the design of existing code without impairing its external behaviour
• Principles and criteria for applying refactoring techniques
• Presentation of the test framework
• Reorganization of methods: how to extract, eliminate, replace or add them
• Reorganization of attributes: how to create, modify or replace accessors, values, references, observed data, associations, and enumerations
• Migration of responsibilities by means of inline, delegation, and helper classes
• Simplification of conditional expressions using subclasses, state/strategy patterns, null objects, and assertions
• Simplification of method invocations to build interfaces and factories
• Moving methods within a hierarchy of classes: how to extract and move attributes and methods

Note: Exercises are done in the Visual Studio 2005 environment with the programming language of your choice.

Objective
To provide the knowledge and skills required to master best practices for managing the evolution of, and the dependencies among, packages, namespaces, and classes, in order to improve the structure, stability and organization of applications.

Target audience
Designers and developers

Prerequisites
Experience with any of the following languages: C++ (Course MN202), C# (Course MN201 or Course MN203), VB.NET (Course MN204) or Java (Course DE204).

Topics covered

• Symptoms of a bad design
• How dependencies impede maintenance, reduce extensibilty, prevent re-use and limit testability
• The key to the problem: managing dependencies
• Advanced object-oriented design: the single responsibility, open/closed, Liskov substitution, dependency inversion and interface segregation principles
• Advanced package design: the reuse/release, common reuse, common closure, acyclic dependencies, stable dependencies and stable abstractions principles
• The use and importance of factories, registries, service locators and embedded containers for Web pages, database connections and logging
• Examples and case studies

Objective
To provide the knowledge and skills required to choose from the available software testing methods and tools in order to establish an effective software testing and validation strategy.

Target audience
Analysts, designers, software developers, quality assurance professionals and project managers.

Prerequisites
Experience in developing systems.

Topics covered

• Definitions of testing concepts
• Software testing as part of the software development process and lifecycle
• Unit, integration, system, acceptance and regression testing
• Black box, white box, grey box formal and informal testing techniques
• Heuristic and exploratory testing
• Test management: V&V, bug classification, tracking and triage
• Test planning, metrics, scheduling, coordinating with development
• Test automation and coverage
• Test case design
• Testing and validation of Web and e-commerce applications
• Ensuring successful projects: choosing tools, evaluating effort and testing costs

Note: The course is given in English, with course material in French.

Objective
To provide the knowledge and skills required to manage and track the evolution of software test plans in a chaotic environment.

Target audience
Analysts, designers, software developers, quality assurance professionals and project managers.

Prerequisites
Experience developing systems.

Topics covered

• Definition of concepts related to testing
• Techniques for planning and organizing tests: Just In Time
• Testing ideas: sources, data acquisition, the life cycle of a testing idea, etc.
• Triage and testing: roles and responsibilities, triage concerns, triage throughout the project lifecycle, implementing triage and adapting to context
• Deciding how to focus testing
• Exploratory tests: definitions, balancing acts, session based exploratory testing, examples of process implementations, accountability
• Adapting to context

Note: The course is given in English, with course material in English.

Objective
To provide the knowledge and skills required to use the best design and development techniques to create embedded systems using the C and B# languages.

Target audience
Embedded application designers, developers and project managers.

Prerequisites
Practical experience with the C language.

Topics covered

• Constraints of embedded applications, and limitations of current technical solutions for 8 to 32 bit microprocessors (Renesas, Arm, Freescale, Microchip, etc.)
• First steps: installation of the B# development tools, embedded software components, polling- and interruption-based processing
• B# language basics: a small object-oriented language (syntax like that of C) for writing device drivers and service interrupt routines
• Resource models: processor, memory, interrupts, peripherals
• Component creation and language abstractions: from C to B#
• Developing concrete and abstract data structures in C
• Overview of data types in C, and classes and objects in B#
• The C procedural model: operators, expressions, statements
• Object-based models: encapsulation, classes, objects, visibility and namespaces
• The object-oriented model: inheritance, aggregation, abstract classes and interfaces
• The framework object for peripherals (LED, LCD, I2C, CAN, A/D, D/A, UART, etc.), and support for multitasking applications

Note: each participant will receive a BDK (BSharp Development Kit) which includes the compiler, the virtual machine and the B# reference manual. More details at www.BSharpLanguage.org.

Objective
To provide the knowledge and skills required to use LINQ to formulate advanced data queries with .NET.

Target audience
Developers.

Prerequisites
Experience with application development using Visual Basic .NET (Course MN204), Visual C# .NET (Courses MN201 or course MN203), Visual C++ .NET (Course MN202), Java (Course DE204) or Visual J# .NET.

Topics covered

• Introduction to Language INtegrated Query (LINQ): requests, filters, sorting and grouping
• Using LINQ requests, filters and operators with .NET collections
• Using database connections, SQL commands, Lambda expressions, stored procedures, the ADO .NET object model and XML schemas
• From LINQ to SQL: mapping objects with LINQ
• From LINQ to XML and .NET 3.5: requests, helper objects and XML output
• Creating requests in an XML document with LINQ
• Transforming an XML document into multiple formats with LINQ
• Reusing SQL requests parameterized with LINQ
• Collections and generics, reflection and attributes: hierarchy, metadata, version management, access to assemblies, serialization, conditional compilation and management of obsolete code

Objective
To provide the knowledge and skills required to develop client-server, multi-tier and web services applications for SOA with .NET

Target audience
Developers.

Prerequisites
Experience with application development using Visual Basic .NET (Course MN204) or Visual C# .NET (Courses MN201 or course MN203), and a good understanding of the principles of SOA (Course DE122)

Topics covered

• Differences between object-oriented, component-oriented and service-oriented architectures
• Using client-server communication libraries, IP addresses, hostnames, URLs, URIs, sockets, TCP, HTTP, FTP, SMTP and remoting
• Creating a basic Web service: localization, utilization, the role of SOAP, WSDL, clients and proxies
• Essential concepts of WCF: services, addresses, contracts, hosting, bindings and endpoints
• Creating a Web service with WCF: configuration, service and data contracts
• Managing service instances: per-call, sessionful and singleton
• Organizing classes and resources for programming threads, and synchronization
• Guidelines for WCF coding