The essentials of modern software engineering : free the practices from the method prisons! / Ivar Jacobson, Harold "Bud" Lawson, Pan-Wei Ng, Paul E. McMahon, Michael Goedicke.

Format:

Book

Author/Creator:

Jacobson, Ivar, author.

Lawson, Harold W., author.

Ng, Pan-Wei, 1969- author.

McMahon, Paul E., 1949- author.

Goedicke, Michael, author.

Series:

ACM books ; #25.

ACM books, 2374-6777 ; #25

Language:

English

Subjects (All):

Software engineering--Study and teaching.

Software engineering.

Physical Description:

1 online resource (xxviii, 371 pages) : illustrations (chiefly color).

Edition:

First edition.

Place of Publication:

[New York, New York] : Association for Computing Machinery ; [San Rafael, California] : Morgan & Claypool, [2019]

System Details:

Mode of access: World Wide Web.

System requirements: Adobe Acrobat Reader.

Summary:

The first course in software engineering is the most critical. Education must start from an understanding of the heart of software development, from familiar ground that is common to all software development endeavors. This book is an in-depth introduction to software engineering that uses a systematic, universal kernel to teach the essential elements of all software engineering methods. This kernel, Essence, is a vocabulary for defining methods and practices. Essence was envisioned and originally created by Ivar Jacobson and his colleagues, developed by Software Engineering Method and Theory (SEMAT) and approved by The Object Management Group (OMG) as a standard in 2014. Essence is a practice-independent framework for thinking and reasoning about the practices we have and the practices we need. Essence establishes a shared and standard understanding of what is at the heart of software development. Essence is agnostic to any particular method, lifecycle independent, programming language independent, concise, scalable, extensible, and formally specified. Essence frees the practices from their method prisons. The first part of the book describes Essence, the essential elements to work with, the essential things to do and the essential competencies you need when developing software. The other three parts describe more and more advanced use cases of Essence. Using real but manageable examples, it covers the fundamentals of Essence and the innovative use of serious games to support software engineering. It also explains how current practices such as user stories, use cases, Scrum, and micro-services can be described using Essence, and illustrates how their activities can be represented using the Essence notions of cards and checklists. The fourth part of the book offers a vision how Essence can be scaled to support large, complex systems engineering. Essence is supported by an ecosystem developed and maintained by a community of experienced people worldwide. From this ecosystem, professors and students can select what they need and create their own way of working, thus learning how to create ONE way of working that matches the particular situation and needs.

Contents:

Foreword / by Ian Sommerville

Foreword / by Grady Booch

part I. The essence of software engineering.

1. From programming to software engineering

1.1. Beginning with programming

1.2. Programming is not software engineering

1.3. From internship to industry

1.4. Journey into the software engineering profession

2. Software engineering methods and practices

2.1. Software engineering challenges

2.2. The rise of software engineering methods and practices

2.3. The SEMAT Initiative

2.4. Essence : the OMG standard

3. Essence in a nutshell

3.1. The ideas

3.2. Methods are compositions of practices

3.3. There is a common ground

3.4. Focus on the essentials

3.5. Providing an engaging user experience

4. Identifying the key elements of software engineering

4.1. Getting to the basics

4.2. Software engineering is about delivering value to customers

4.3. Software engineering delivers value through a solution

4.4. Software engineering is also about endeavors

5. The language of software engineering

5.1. A Simple practice example

5.2. The things to work with

5.3. Competencies

5.4. Things to do

5.5. Essentializing practices

6. The kernel of software engineering

6.1. Organizing with the Essence kernel

6.2. The essential things to work with : the alphas

6.3. The essential things to do : the activities

6.4. Competencies

6.5. Patterns

7. Reflection on theory

7.1. Where's the theory for software engineering?

7.2. Uses of theory

7.3. Essence is a general, descriptive theory of software engineering

7.4. Toward a general predictive theory of software engineering

7.5. A theoretical foundation helps you grow

8. Applying Essence in the small

playing serious games

8.1. Progress poker

8.2. Chasing the state

8.3. Objective go

8.4. Checkpoint construction

8.5. Reflection

part II. Developing software with Essence. 9. Kick-starting development using Essence

9.1. Understand the context through the lens of Essence

9.2. Agreeing on the development scope and checkpoints

9.3. Agreeing on the most important things to watch

10. Developing with Essence

10.1. Planning with Essence

10.2. Doing and checking with Essence

10.3. Adapting a team's way of working with Essence

10.4. How the kernel helps adapt their way of working

11. The development journey

11.1. Visualizing the journey

11.2. Ensuring progress and health

11.3. Dealing with anomalies

12. Reflection on the kernel

12.1. Validity of the kernel

12.2. Applying the kernel effectively

part III. Small-scale development with practices. 13. Kick-starting development with practices

13.1. Understand the context through the lens of Essence

13.2. Agree upon development scope and checkpoints

13.3. Agree upon practices to apply

13.4. Agree upon the important things to watch

13.5. Journey in brief

14. Running with scrum

14.1. Scrum explained

14.2. Practices make a software engineering approach explicit and modular

14.3. Making scrum explicit using Essence

14.4. Scrum lite alphas

14.5. Scrum lite work products

14.6. Scrum lite roles

14.7. Kick-starting scrum lite usage

14.8. Working with scrum lite

14.9. Reflecting on the use of scrum with Essence

15. Running with user story lite

15.1. User stories explained

15.2. Making the user story lite practice explicit using Essence

15.3. User story lite alphas

15.4. User story lite work products

15.5. Kick-starting user story lite usage

15.6. Working with user story lite

15.7. The value of the kernel to the user story lite practice

16. Running with use case lite

16.1. Use cases explained

16.2. Making the use case lite practice explicit using Essence

16.3. Use case lite alphas

16.4. Use case lite work products

16.5. Kick-starting use cases lite to solve a problem our team is facing

16.6. Working with use cases and use-case slices

16.7. Visualizing the impact of using use cases for the team

16.8. Progress and health of use-case slices

16.9. User stories and use cases

what is the difference?

17. Running with microservices

17.1. Microservices explained

17.2. Making the microservice practice explicit using Essence

17.3. Microservices lite

17.4. Microservices lite alphas

17.5. Microservices lite work products

17.6. Microservices lite activities

17.7. Visualizing the impact of the microservices lite practice on the team

17.8. Progress and health of microservice development

18. Putting the practices together : composition

18.1. What is composition?

18.2. Reflecting on the use of essentialized practices

18.3. Powering practices through essentialization

part IV. Large-scale complex development

19. What it means to scale

19.1. The journey continued

19.2. The three dimensions of scaling

20. Essentializing practices

20.1. Practice sources

20.2. Monolithic methods and fragmented practices

20.3. Essentializing practices

20.4. Establishing a reusable practice architecture

21. Scaling up to large and complex development

21.1. Large-scale methods

21.2. Large-scale development

21.3. Kick-starting large-scale development

21.4. Running large-scale development

21.5. Value of Essence to large-scale development

22. Reaching out to different kinds of development

22.1. From a practice architecture to a method architecture

22.2. Establishing a practice library within an organization

22.3. Do not ignore culture when reaching out

23. Reaching out to the future

23.1. Be agile with practices and methods

23.2. The full team owns their method

23.3. Focus on method use

23.4. Evolve your team's method

Appendix A. A brief history of software and software engineering.

Notes:

Includes bibliographical references (pages [349]-351) and index.

Title from PDF title page (viewed on August 15, 2019).

Other Format:

Print version:

ISBN:

9781947487253

9781947487260

OCLC:

1112372868

Access Restriction:

Restricted for use by site license.