1. Concurrent software can simultaneously run multiple computations that potentially interact with each other.
Networked software defines protocols that enable computing devices to exchange messages & perform services remotely.
Motivations for Concurrent software:
1) Leverage hardware/software advances. multi-core processors and multi-threaded operating systems.
2) Simplify program structure by allowing blocking operations.
3) Increase performance: Parallelize computations and communications.
4) Improve response-time
Challenges for Concurrent software:
1) Accidental Complexities: Tedious, error-prone, non-portable Low-level API. Limited debuging tools
2) Inherent Complexities: Synchronization, Scheduling, Deadlock
Motivations for Networked software:
1) Collaboration & commerce: file sharing, social media, e-commerce.
2) Scalability: cloud computation.
3) Availability: minimizing single points of failure via replication.
4) Cost effectiveness via shared resources.
Challenges for Networked software:
1) Accidental Complexities: Algorithmic decomposition. Continuous re-discovery & re-invention of core components,
2) Inherent Complexities: Latency & jitter, Reliability & partial failure. Security
Describe how patterns & frameworks help address challenges of concurrent & networked software
Patterns:
1)Present solutions to common problems arising within a context.
2) Help balance & resolve key software design forces.
3) Capture recurring structures & dynamics among software elements to facilitate reuse of successful designs.
4) Codify expert knowledge of design strategies, constraints & “best practices”.
Frameworks: are integrated sets of software components that collaborate to provide reusable architectures for families of related applications.
1) exhibit “inversion of control” via callback.
2) provide integrated domain-specific structures & functionality.
3) They are “semi-complete” applications.
Patterns & frameworks codify proven experience to enable
1) Design reuse - Match problems to relevant structures/dynamics & patterns in a domain.
2) Code reuse – Reify proven designs within particular development environments & domains.
Course Syllabus:
Section 1 – Introduction to concurrent & networked software: Layers, design dimensions, OS programming mechanism, Android programming mechanisms.
Section 2 – Introduction to Patterns & frameworks
Section 3 – Applying patterns & framework to concurrent & networked software. : Event handling, Concurrency, Synchronization.
Week 1.
1. Discuss key layers in concurrent & networked software:
1) Layered architecture create a multi-tier architecture that separates concerns between tasks in different system layers.
Middleware is reusable infrastructure software residing between applications & the underlying operating systems, networks, & hardware.
Middleware leverage hardware & software technology advances, evolve to new requirements & environments, provide an array of reusable, off-the-shelf developer-oriented services. Control end-to-end resources & quality of service (QoS).
Applications
Domain-specific middleware service: are tailed to the requirements of particular domains.
Common Middleware servicees: define higher-level domain-independent services. CORBA component, J2EE, .NET, Webs services.
Distribution Middleware: simplifies networked component programming & extends OS mechanisms end-to-end. CORBA, SOAP, RMI, DCOM.
Host Infrastructure Middleware: encapsulates/enhances native OS mechanisms to create reusable OO components JVM, CLR
Operating Systems & protocols
Hardware
Pros & Cons of Layers Pattern:
Pros: 1) Reuse of layers, Support for standarization, Dependencies are localized. Exchangeability,
Cons: Cascades of changing behavior, Higher overhead, Unnecessary work, Difficulty of establishing the correct granularity of layers.
2. Explore key design dimensions of concurrent & networked software
Connection-oriented vs. Connectionless Protocols
Data Encoding strategies: Text-based, binary
Connection Multiplexing Strategies: multiplexed connection, nonmultiplexed connection
Sync vs. Async Message Exchange
Message Passing vs. Shared memory
Services, Servers, Configurations
Short vs. Long duration services.
Internal vs. External Services
Monolithic vs. Layered/Modular Services
Single Service vs. Multi-service Servers
One-shot vs. standing Servers
Static vs. Dynamic linking & Configuration.
3. Survey key operating system concurrent & networked software mechanisms & API
Iterative vs. Concurrent Servers.
Multiprocessing vs. Multithreading
Thread/Process Pool Eager Spawning Strategies: Prespawn, On-demand spawning
Kernel- vs. User-level Threading models. Hybrid threading model.
Task- vs. Message-based Architectures
Describe key Android concurrent & networked software mechanisms & APIs
