Devops for Growth
107.5K views | +0 today
Follow
Devops for Growth
For Product Owners/Product Managers and Scrum Teams: Growth Hacking, Devops, Agile, Lean for IT, Lean Startup, customer centric, software quality...
Curated by Mickael Ruau
Your new post is loading...
Your new post is loading...

Popular Tags

Current selected tag: 'agile modeling'. Clear
Scooped by Mickael Ruau
Scoop.it!

agilemodeling.com

Agile Modeling (AM) is a practice-based methodology for effective modeling and documentation. Models are sometimes called maps or roadmaps within the agile community. Agile models can be something as simple as stickies on a wall, sketches on a whiteboard, diagrams captured digitally via a drawing tool, or executable models captured using a model-based software engineering (MBSE) tool. Agile documents can be something as simple as point-form notes, detailed text, executable tests, or one or more agile models.

Mickael Ruau's insight:

Agile Modeling Strategies

Mindset

 

 

 

 

 

 

 

People

 

 

 

 

 

 

 

Disciplines

 

 

 

 

 

 

 

   

 

 

 

 

 

 

Modeling Strategies

 

 

 

 

 

 

Modeling Sessions

 

 

 

 

 

 

 

Session Types

 

 

 

 

 

 

 

Specification Strategies

 

 

 

 

 

 

 

   

 

 

 

 

 

 

Related Techniques

 

 

 

 

 

 


Other Pages At This Site:

 

Important External Links

No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Agile modeling - Wikipedia

Agile modeling - Wikipedia

Agile modeling (AM) is a methodology for modeling and documenting software systems based on best practices. It is a collection of values and principles, that can be applied on an (agile) software development project. This methodology is more flexible than traditional modeling methods, making it a better fit in a fast changing environment.

No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Agile Modeling (AM) Home Page: Effective Practices for Modeling and Documentation

Agile Modeling (AM) Home Page: Effective Practices for Modeling and Documentation | Devops for Growth | Scoop.it

Important Pages At this Site:

 

Important External Links

No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Agile Modeling: Definition, Core Principles And Advantages

Agile Modeling: Definition, Core Principles And Advantages | Devops for Growth | Scoop.it

Simply put, Agile Modeling (AM) is a collection of values, principles, and practices for modeling software that can be applied on a software development project in an effective and lightweight manner.”

The modeling adds to existing Agile methodologies such as the Rational Unified Process (RUP) or extreme programming (XP). Agile modeling helps developers create a customized software development process that fulfills their development needs yet is flexible enough to adjust to future situations.



What is Agile Modeling: An Introduction
Mickael Ruau's insight:

The Pros and Cons of Agile Modeling

The modeling brings advantages and disadvantages to the table.

Advantages

  • Facilitates effective communication between teams and clients
  • Enhances project flexibility, easily handling sudden changes anytime
  • Cuts overall development time
  • Increases customer satisfaction via rapid, continuous delivery of a workable product
  • Delivers functioning software frequently, in weeks instead of months

Disadvantages

  • Confusion between teams may develop because documentation wasn’t emphasized. This uncertainty can lead to difficult transitions between phases.
  • It is sometimes difficult to gauge how much effort will be needed to start the development life cycle of larger software deliverables.
  • If stakeholders project ladder are not on the same page, the project will derail.
  • The modeling isn’t for newbies. The sort of decisions involved in Agile require people with experience and solid developer and programming skills.           
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Entity-control-boundary - Wikipedia

Entity-control-boundary

The Entity-Control-Boundary ( ECB), or Entity-Boundary-Control ( EBC), or Boundary-Control-Entity ( BCE) is an architectural pattern used in use-case driven object-oriented software design that structures the classes composing a software according to their responsibilities in the use-case realization. The Entity-Control-Boundary approach finds its origin in Ivar Jacobson's use-case driven OOSE method published in 1992,.

Mickael Ruau's insight:

Robustness diagram

Robustness diagrams allow to visually represent the relation between entities, controls, boundaries and actors.[4] It uses graphical stereotypes introduced in Jacobson's early work:  

Representation Relation with Role Symbol Actor Boundary Control Entity Actor Yes Yes No No Boundary Yes Part/whole Yes No Control No Yes Yes Yes Entity No No Yes Yes

The following robustness contraint apply: 

  • Actors may only know and communicate with boundaries
  • Boundaries may communicate with actors and controls only.
  • Controls may know and communicate with boundaries and entities, and if needed other controls
  • Entities may only know about other entities but could communicate also with controls;

In principle entities should not know about boundaries and controls. In practice however, some variants allow entities, boundaries and controls to subscribe as observer to an entity.

Similarly, the constraint of a boundary class not knowing about another boundary classes only applies at the highest level, and not between classes that cooperate to implement the same boundary.

Relation to other architectural patterns

There is some similarity between ECB and Model-view-controller (MVC): entities belong to the model, and views belongs to boundaries.  However the role of the ECB-control is very different from MVC-controller, since it encapsulates also use-case business logic whereas the MVC controller processes user input which would be of the responsibility of the boundary in ECB.  The ECB control increases separation of concerns in the architecture by encapsulating business logic that is not directly related to an entity.[2]  

The ECB can be used in conjunction with the hexagonal architecture, whenever the boundaries form the outer adapte layer.[10]  

ECB is  compatible with the clean architecture which merges ECB principles with other architectural design[11],.[12]  Clean architecture places entities at the core, and surround them with a use-case ring (i.e. ECB control) and a ring with gateways and presenters (i.e. ECB boundaries).  However, clean architecture requires a one-way dependency from outside to inside, which requires to split ECB controls into use-case logic and object coordination.    

No comment yet.