《Models to Code With No Mysterious Gaps》英文原版PDF

需积分: 10 60 浏览量更新于2023-05-25 收藏 18.32MB PDF 举报

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

30元优惠券

"Models to Code With No Mysterious Gaps" 是一本由 Leon Starr, Andrew Mangogna 和 Stephen Mellor 合著的专业IT书籍，主要探讨如何在软件开发过程中建立清晰、连贯的模型，以便将这些模型直接转化为代码，减少理解和实现过程中的歧义和错误。这本书的英文原版无水印，适用于多种PDF阅读器打开，如FoxitReader、PDF-XChangeViewer、SumatraPDF和Firefox。如果存在任何版权问题，可以联系上传者或CDN删除。本书可能涉及的知识点包括： 1. **模型驱动开发（Model-Driven Development, MDD）**：这是一种软件工程方法，它强调通过构建高级别的模型来描述软件系统，然后自动或半自动地将这些模型转换为实际的代码。 2. **统一建模语言（Unified Modeling Language, UML）**：UML是一种标准的图形建模语言，用于可视化、规格化和构建各种软件系统。书中可能介绍了如何使用UML来创建无歧义的模型，避免“神秘的缝隙”。 3. **领域特定语言（Domain-Specific Languages, DSLs）**：DSL是为特定领域或问题设计的编程语言，可以使模型更贴近问题域，提高开发效率。作者可能讨论了如何创建和应用DSL以消除理解模型时的复杂性。 4. **模型验证与转换**：书中可能会涵盖验证模型正确性的方法，以及如何从一个模型平滑地转换到另一个模型，确保模型到代码的过程是准确无误的。 5. **软件生命周期管理**：作者可能讨论了如何在整个软件开发过程中，从需求分析、设计、实现到测试，保持模型的一致性和完整性，减少“神秘的缝隙”。 6. **敏捷开发与模型的关系**：考虑到敏捷方法的流行，书中可能探讨了如何在敏捷环境中有效地使用模型，以适应快速变化的需求。 7. **代码生成工具和技术**：书中可能介绍了各种工具和技术，它们可以帮助开发者将模型自动转换为高质量的源代码，从而减少手动编码的工作量和出错的可能性。 8. **最佳实践与案例研究**：作者可能分享了一些成功的项目实例，展示了如何使用模型到代码的方法解决实际问题，以及在实践中遵循的最佳实践。 9. **质量保证与维护**：书中可能讨论了如何通过清晰的模型来提高代码的可读性、可维护性和可扩展性，以降低长期的维护成本。 10. **知识产权与法律问题**：由于提到版权信息，书中有提及对知识产权的尊重，可能也涉及软件开发中的法律和合规问题，特别是在使用和传播模型或代码时应注意的事项。 "Models to Code With No Mysterious Gaps" 是一本面向软件工程师、架构师和项目经理的专业书籍，旨在帮助他们构建更清晰、更易于理解的模型，并有效地将这些模型转化为实际的代码，提高软件开发的效率和质量。

资源详情

资源推荐

About the Authors

Leon Starr has been developing real-time distributed and embedded

software with object-oriented, executable models since 1984. His models

have been used in fighter jets, factory material transport control systems,

ultrasound diagnostic and cardiac pacing systems, gas chromatography

and semiconductor wafer inspection systems, video postproduction

systems, and networked military battle simulators. He has taught

numerous courses on executable systems and data modeling to systems

engineers and software developers worldwide through his company Model

Integration, LLC (modelint.com) based in San Francisco, California. He

is the author of How to Build Shlaer-Mellor Object Models, How to Build

Class Models, Executable UML: A Case Study, and assorted papers at

uml.org and modeling-languages.com. He regularly assists project teams

who model complex requirements and generate code from those models

for challenging hardware and software platforms.

Andrew Mangogna has developed a number of open source tools,

including pycca, which we use in this book to specify Executable UML

models and translate them into code. He has also worked extensively

in the medical device community. For more than 30 years, Andrew has

been a hands-on builder of embedded software systems. He has worked

in application areas ranging from laboratory instrumentation, remote

data collection, and video special effects, to implantable medical devices.

Andrew has always had a special interest in applying more formal

techniques to the challenge of engineering software to create systems in

a cost-effective manner with demonstrable quality. Trained in the basics

of modeling by Stephen Mellor himself, he has successfully applied

executable modeling techniques and model translation to many projects

and has written several tools to help automate the translation process.

With a keen interest in technology and a practical realization of the

benefits of modeling, he has a mastery of mapping models to appropriate

implementation technology to obtain high-quality software systems.

xvii

Acknowledgments

Any substantial project always depends on the generous help of others. Friends, colleagues, and a host of

experiences have provided valuable service to Models to Code.

We all wish to thank Ed Seidewicz, our technical reviewer, for his many insightful and detailed

comments throughout the text. His eye for detail rooted out quite a few potential and devilishly subtle errors.

He passed many of our “tests” to see whether he was actually reading this stuff. We especially appreciate

his patience with us, as we are well aware that our opinions and experience are often at odds with current

practice in the greater UML community.

I want to express my heartfelt thanks to friends and colleagues who expressed early enthusiasm for

this project. This includes many of my colleagues at SAAB Aerospace here in Sweden. At the Por Que No?

taqueria in Portland, Oregon in March of 2016, Dan George and I had some amazing tacos, and I was

encouraged by his infectious comments and enthusiasm. Back here in Linköping, Sweden, my present home

base, I enjoyed many beers, laughs, and technical discussions with Nils Paulsson of SAAB at The Bishops

Arms pub. He also contributed helpful comments on early drafts (in both the writing and beer sense of the

word). Thanks also to my Scandinavian “agent” and good friend, Christer Andersson, for equal measures of

encouragement and pestering me to get this project over with so I could get back to doing “real” work. My

longtime friend and business partner, Michael M. Lee, has served many a quality margarita on my recurring

visits back to the Bay Area in California. I would like to thank the staff at Babbettes Kafferie in Linköping for

letting me use a corner of their cafe as my second office and keeping me well supplied with coffee, morning

buns, and warm conversation during the dark and cold Swedish winter days. Most important, though, I owe

a massive debt of gratitude to my wife, Kristina, who set me up with a beautiful home office and forbade me

from getting a new Xbox until the book was complete and for putting up with my writing throughout our

summer wedding plans. Along with Andrew’s superb project management skills, you can thank her the most

for this book making it to the shelves in 2017.

—Leon Starr

The many discussions over coffee and beer of modeling and its foundations with Paul Higham were

fundamental to a broader understanding of how all the pieces fit together. There were many people, such as

Melanie Gurunathan, Cary Campbell, and Thomas Brennan-Marquez, who actually used pycca to deliver

real products and whose feedback was essential. Finally, without the patience and support of my wife,

Marjorie Lane-Mangogna, it is hard to envision how this book could ever have happened. Few would have

the patience to deal with the blah, blah, blah chatter that surrounds someone immersed in writing on a

technical subject.

—Andrew Mangogna

xix

Foreword

I published my first book on requirements analysis and modeling back in 1997. It was based on my

experience working with teams to build complex, real-time, model-driven software. Like so many other

books on software modeling, I left the process of transforming the models into code as an exercise for the

student. Ha!

In fact, on actual projects, we were able to make this transformation, but it certainly wasn’t easy.

Worthwhile, yes. The models proved themselves again and again as being worth the effort. But the code

translation problem has never been trivial. We always required a small team dedicated to the translation task

running in parallel with the modeling effort. Note that this was not a waterfall approach, as modeling and

design were being accomplished simultaneously.

Over time, the tools and technology to bridge the path from models to code improved. Unfortunately,

they were locked up in proprietary solutions and expensive licensed products. This put me in an awkward

position when extolling the benefits of modeling to younger engineers. Getting them interested in the

benefits of modeling and a more promising style of model execution and code generation was easy. I would

then be confronted with the inevitable question, “That’s sounds great; how do I get started with this stuff?”

I then had to concede that, while you might toy around with the ideas on your own, you really needed to get

attached to a project that could fund the required tooling. Consequently, I didn’t want to write another book

without giving the reader a real path, any path, that took the models into running code without requiring the

purchase of any expensive tools.

Andrew and I have worked together on and off on various projects over the years. One of his early

translation systems extracted models from a tool called BridgePoint at the time (now xtUML) and

transformed those models directly into assembly language. Because of the specialized CPU, no sufficiently

optimal C compiler was available. It was a proprietary solution for a particular embedded device company,

but it was a compelling proof of concept. Abstract models could be compacted and reorganized directly to

the machine instruction level and run on specialized and limited resource hardware to yield the precise

behavior specified by the models.

Andrew has since moved on to build a number of open source translation systems of which one, pycca,

is used in this book. I eventually realized that these open source tools were the key to explaining how to

bridge the gap from models to code while providing an accessible solution to any interested party.

Thus began our latest book project. After coaxing Andrew to take part, and enticing the primary author

of Executable UML and Agile signatory, Stephen Mellor, to join in, we had the perfect mix of expertise.

As you read along, you may find that this is not an easy subject, and may require some hard work to

make it through. The reward is the ability to take executable models that solve real problems through to an

efficient implementation without destroying the models in the process. I want you to know that you are not

alone in this journey, and we’re more than happy to help if you have questions or run into obstacles. Feel

free to use our contact page at the end of the book. Happy reading!

—Leon Starr

Linköping, Sweden

March 15, 2017

xxi

xxii

■ Foreword

In conversations with colleagues who share a similar outlook about software development, the topic

invariably turns to why the practice of software development using models and translation is not more

widespread. Many reasons are offered, but usually the conversation trails off into consternation over an

industry that claims to want well-engineered software juxtaposed to the repeated practices that do not

deliver.

For my part, I have concluded that modeling and translation are hard because abstraction is hard

and requires practice to master. One need only look at the facial contortions of a young teenager when

initially exposed to the idea of variables in beginning algebra to understand that we are creatures first of the

immediate and concrete. Gone are the comforts of explicit numbers, and suddenly a new set of rules is in

place to cope with the idea that an arbitrary symbol, which doesn’t look anything like a numeral, can now

range over many values. The look is similar to that of a beginning programming student struggling to fix

firmly the difference between a variable and the value contained in the variable when the same symbol is

used for both and only context provides the distinction. Even though I have successfully produced software

systems using modeling and translation for many years, there are times when looking at pages of boxes and

arrows that it is hard to see how the gap between symbols on a page and running software will ever be filled.

It looks like a jump across the Grand Canyon to be attempted only by an extreme stunt rider equipped with a

magic, rocket-propelled vehicle.

The young algebra student, by working through many specific problems, does come to grasp the

underlying abstractions. Reasoning, and sometimes wrestling, with the concrete yields up the abstract.

In this book, we undertake to illustrate general principles of translating models into code by examining

specific examples. We practice a specific way to model requirements and translate to a specific type of target

platform using a specific programming language. We hold tightly to our tagline of “no mysterious gaps” in

our attempt to show, at each step along the way, exactly how the translated software is produced and runs.

We show lots of models and lots of code, confident in the awesome power of an individual to grasp the

abstractions embedded in the specifics.

There is a danger that some readers will look at the details of the platform or translation technique

and conclude that, because the specifics don’t match their interests or preferences, the idea of translating

models into programs is itself not generally applicable. In that case, we will have failed as authors to provide

the vision of model translation as a tangible engineering approach. But I am confident that there are readers

who will realize that symbols on a diagram can be made tangible as a running program (as tangible as

software ever is) and that obtaining code by translating models looks more like driving over a bridge than

jumping the Colorado river.

—Andrew Mangogna

Nipomo, California

March 15, 2017

剩余317页未读，继续阅读

yinkaisheng-nj

粉丝: 762
资源: 6231

《Models to Code With No Mysterious Gaps》英文原版PDF

TypeScript Design Patterns 无水印pdf

Beautiful Code 无水印原版pdf

Programming Languages and Systems 无水印pdf

Please help me write a review of the movie 'A Beautiful Mind', with a requirement of 1000 words

They were the last people you’d expect to be involved in anything strange or mysterious语法分析

请以《开学》为题，写一篇1000字以上的悬疑主题小说

Give a brief introduction to a novel including the following aspects: - genre - characters - plot - setting - theme

Anya and the Mysterious String的代码

起标题，每个标题50字以上，与传奇3，超高爆率，复古怀旧，元素觉醒，七大元素，十三魔法，神舰跑船，三端互通，原汁原味，经典玩法，经典三职业，需要30份不同的标题

请写一段生动且富有逻辑的英文，包含以下单词：messy, miserable, marvelous, grand, innocent, greedy, messy, mysterious

当inde=0时想执行下列代码{ERROR} {sprintf(cin[i++].s,"Error type (Lexical) at line %d: Mysterious character \"%s\".\n",line,yytext);}应该怎么写

A picture of forest

c++密室逃脱游戏代码

entry标签在xml中应用的代码实例

. { inde=0; printf("Error type (Lexical) at line %d: Mysterious character \"%s\".\n",line,yytext);是什么意思

用Python写一个作诗程序

SQL实现图书管理完整代码

用C#写一个MUD引擎

最新资源