Real-TimeDesignPatterns

需积分: 4 56 浏览量更新于2023-03-03 评论收藏 208KB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

Real-Time Design Patterns Many of us have had the experience of working with a truly great software designer. They have the ability to look at a really hard problem and seemingly with no effort construct an elegant and practical solution. Afterward, we all slap our foreheads and say “Of course! It’s so obvious!1” How do those Great Designers actually come up with these great designs in the first place? By training, I am a neurophysiologist. During my medical school years, I primarily studied information processing in biological neural systems2. The process of coming up with Good Designs occurs in three phases: · Internalization · Pattern Matching · Sequential Analysis The first phase, internalization, is a linear process of gathering information. What are the functions of the design? What are its constraints? What aspects of the design should be optimized at the expense of others? This is a process of gathering and organizing information about the system under design. The second phase, pattern matching, is an inherently nonlinear process and is performed almost exclusively by the subconscious mind. It is exactly this kind of thinking that has occurred place when The Answer suddenly comes to you in the shower or when you wake in the middle of the night. It often happens to me when I go for a run. I even go so far as to classify problems by how far I think I’ll have to run to come up with a solution. I might tell my boss, “Gee, that’s a 10-mile problem. I’ll see you in a couple of hours – bye!3” I believe that subconsciously our rather impressive pattern matching apparatus goes to work on a pre-analyzed problem (that’s where the internalization phase comes in) and does “best fit” pattern matching comparing thousands of patterns while our conscious mind is off doing other things. Only when it finds a close-enough match (a potential design solution) does it signal the conscious mind. Just because the subconscious thinks it has found a good solution is no guarantee of the quality of the proposed solution. Once identified, it is up to the linear processing system of the brain to take the proposed solution and see if it does in fact meet our criteria. This is the process of sequential analysis that is applied to a proposed solution. Most often, this takes the form of mentally applying scenarios against the design pattern to ensure that it in fact meets the necessary criteria and optimizes all the right things.

资源详情

资源评论

资源推荐

Real-Time Design Patterns Bruce Powel Douglass, Ph.D. i-Logix

Real-Time Design Patterns

Bruce Powel Douglass, Ph.D.

Chief Evangelist

I-Logix, Inc.

www.ilogix.com

Introduction

Many of us have had the experience of working with a truly great software designer. They

have the ability to look at a really hard problem and seemingly with no effort construct an

elegant and practical solution. Afterward, we all slap our foreheads and say “Of course!

It’s so obvious!

” How do those Great Designers actually come up with these great

designs in the first place?

By training, I am a neurophysiologist. During my medical school years, I primarily

studied information processing in biological neural systems

. The process of coming up

with Good Designs occurs in three phases:

Internalization

Pattern Matching

Sequential Analysis

The first phase, internalization, is a linear process of gathering information. What are the

functions of the design? What are its constraints? What aspects of the design should be

optimized at the expense of others? This is a process of gathering and organizing

information about the system under design.

The second phase, pattern matching, is an inherently nonlinear process and is performed

almost exclusively by the subconscious mind. It is exactly this kind of thinking that has

occurred place when The Answer suddenly comes to you in the shower or when you wake

in the middle of the night. It often happens to me when I go for a run. I even go so far as

Actually, I prefer to slap someone else’s forehead.

Mostly in the subesophageal ganglion of the Hirudo medicinalis (a.k.a., the medicinal

leech), which, behaviorally has more in common with marketing folks than engineers, but

I believe the same rules apply.

Parts of this paper have been adapted from the author’s book Real-Time UML:

eveloping Efficient Objects for Embedded Systems (Addison-Wesley, 1998) and

oing Hard Time: Developing Real-Time Systems with UML, Objects, Frameworks,

and Patterns (Addison-Wesley, 1999).

Back

Real-Time Design Patterns Bruce Powel Douglass, Ph.D. i-Logix

composed of three parts: a problem context, a generalized approach to a solution, and a

set of consequences.

Design patterns are usually constructed by extracting out the things in common from a

large set of specific instances. This process is called abstraction or inductive reasoning.

For example, C++ programs are riddled

with pointers. There are a number of commonly

occurring problems with pointers:

If pointers go out of scope without the memory to which they point being

recovered, the memory is no longer accessible (memory leak)

Even if programmers remember to match up every new with a corresponding

delete, if an exception is thrown before reaching the delete, a memory leak will

occur

If pointers are used prior to being initialized, they can corrupt system memory

(uninitialized pointers)

If pointers are used after the memory to which they point has been recovered, they

can corrupt memory that has been reused by the system (dangling pointer)

If multiple pointers to the same memory location are released, this can corrupt the

heap beyond repair (multiple delete)

So here we have a problem context: pointers are enormously useful for all kinds of

programming tasks, but their use can lead to errors because there are no safeguards built

into the language.

A generalized approach to a solution is to wrap raw pointers used within functions inside

of a class. Let’s see how the use of such smart pointer classes helps:

Memory leak: Raw pointers do not have destructors that guarantee proper

memory release. However, when objects go out of scope, their destructors are

called. This allows memory to be properly released regardless of how the

object goes out of scope.

Uninitialized pointer: a class can use attributes and methods to ensure that its

preconditional invariants are met prior to use. Specifically, a smart pointer

object can check to see whether or not it has been initialized.

Dangling pointer: Once the memory pointed to has been released, the smart

pointer can remember that fact and disallow further access.

Multiple delete: If several pointers to the same storage are used, a smart

pointer can keep track of them and automatically delete the referenced

memory if and only if the last pointer is deleted.

The last characteristic of a design pattern is the set of consequences of the pattern.

Specifically

There is a small amount of overhead associated with the smart pointer:

Prior to each access, the pointer should be checked to ensure that it is

currently valid

I mean that in every sense of the word.

Real-Time Design Patterns Bruce Powel Douglass, Ph.D. i-Logix

A small amount of memory must be used to keep a reference count to

track the number of currently valid pointers to the referenced memory

Discipline must be enforced so that no one inadvertently uses raw pointers to

the same memory

Phases of Design

I break up design into three phases: architectural, mechanistic, and detailed design.

Architectural design is concerned with large-scale strategic decisions that have broad and

widely-ranging effects. Architectural decisions include the placement of software

modules on different processors, real-time scheduling policies, identification of

concurrency models, and inter-processor and inter-thread communication.

Mechanistic design is so named because it deals with the construction of mechanisms –

groups of objects that collaborate together for medium-sized purposes. Typically,

mechanisms include a small number of objects, from two to a dozen or so.

Detailed design is concerned with the details of the object innards – data structuring and

typing, internal algorithms, visibility and interfaces.

Notation

The UML (Unified Modeling Language) provides a notation for design patterns but this

notation is targeted primarily towards mechanistic design patterns. The reason is that this

is the area receiving the lion’s share of research interest. Nevertheless, the notational

schema works for architectural design as well. In this paper, we will not discuss detailed

design patterns in order to limit its size.

The UML pattern notation is based on the UML class diagram. The elements of most

interest are:

Pattern (shown as a named oval)

Class (shown as a named rectangle)

Object (shown as a named rectangle in which the name is underlined)

Package (shown as a tabbed folder)

Relation

Association (shown as a line connecting classes or objects)

Aggregation (“has-a” – shown as an association with a diamond at the owner-end)

Composition (a strong form of aggregation – shown with containment of classes

within classes or with filled diamonds)

Generalization (shown as an open arrow pointing to the more general class)

Refinement (e.g. instantiation of templates into classes)

A sample design pattern looks like figure 1.

剩余38页未读，继续阅读

LanceJin

粉丝: 26
资源: 118

会员权益专享

Real-Time Design Patterns

评论0

会员权益专享

最新资源

Real-Time Design Patterns

评论0

Data Structures And Algorithms With Object-Oriented Design Patterns In C Sharp.pdf

M. S. Joshi - C++ Design Patterns and Derivatives Pricing - CUP[2008]2Ed.pdf

GO语言设计模式 go-design-patterns

cloud-design-patterns微软中文翻译版本

java-design-patterns

patterns, principles, and practices of domain-driven design mobi pdf

Design Patterns in PHP and Laravel [2017]

JavaScript Domain-Driven Design(PACKT,2015)

Learning JavaScript Design Patterns - Addy Osmani.pdf

Packt - Mastering JavaScript Design Patterns, 2nd Edition (Jun 2016)

《Java Design Patterns》高清完整英文PDF版

design patterns elements of reusable object-oriented software下载

Service Design Patterns

23 design patterns in C++ code

来凯医药(02105.HK)深度研究报告：Afuresertib有望美国报产，ActRIIA单抗增肌减脂潜力巨大.pdf

会员权益专享

最新资源