“Notes” category

OK, that’s enough. Too much posts for a single day.
 
Today’s posts mainly go into a new category "Notes". I’m thinking that, I should have a habit to collect and archive some goodies for later reference purpose.
 
Hope my readers also can find something making sense for them.
 
“Notes” category

Why Model?

Why do engineers build models? Why do aerospace engineers build models of aircraft? Why do structural engineers build models of bridges? What purposes do these models serve?

These engineers build models to find out whether their designs will work. Aerospace engineers build models of aircraft and then put them into wind tunnels to see whether they will fly. Structural engineers build models of bridges to see whether they will stand. Architects build models of buildings to see whether their clients will like the way they look. Models are built to find out whether something will work.

This implies that models must be testable. It does no good to build a model if you cannot apply criteria to that model in order to test it. If you can’t evaluate the model, the model has no value.

Why don’t aerospace engineers simply build the plane and try to fly it? Why don’t structural engineers simply build the bridge and then see whether it stands? Very simply, airplanes and bridges are a lot more expensive than the models. We investigate designs with models when the models are much cheaper than the real thing we are building.

Why Build Models of Software?

Can a UML diagram be tested? Is it much cheaper to create and test than the software it represents? In both cases, the answer is nowhere near as clear as it is for aerospace engineers and structural engineers. There are no firm criteria for testing a UML diagram. We can look at it, evaluate it, and apply principles and patterns to it, but in the end, the evaluation is still subjective. UML diagrams are less expensive to draw than software is to write but not by a huge factor. Indeed, there are times when it’s easier to change source code than it is to change a diagram. So when does it make sense to use UML?

I wouldn’t be writing some of these chapters if UML didn’t make sense to use. However, UML is also easy to misuse. We make use of UML when we have something definitive we need to test and when using UML to test it is cheaper than using code to test it. For example, let’s say that I have an idea for a certain design. I need to test whether the other developers on my team think that it is a good idea. So I write a UML diagram on the whiteboard and ask my teammates for their feedback.

Should We Build Comprehensive Designs Before Coding?

Why do architects, aerospace engineers, and structural engineers all draw blueprints. The reason is that one person can draw the blueprints for a home that will require five or more people to build. A few dozen aerospace engineers can draw blueprints for an airplane that will require thousands of people to build. Blueprints can be drawn without digging foundations, pouring concrete, or hanging windows. In short, it is much cheaper to plan a building up front than to try to build it without a plan. It doesn’t cost much to throw away a faulty blueprint, but it costs a lot to tear down a faulty building.

Once again, things are not so clear-cut in software. It is not at all clear that drawing UML diagrams is much cheaper than writing code. Indeed, many project teams have spent more on their diagrams than they have on the code itself. It is also not clear that throwing away a diagram is much cheaper than throwing away code. Therefore, it is not at all clear that creating a comprehensive UML design before writing code is a cost-effective option.

Why Model?

Principles behind the Agile Manifesto

The values in the Manifesto for Agile Software Development inspired the following 12 principles. These principles are the characteristics that differentiate a set of agile practices from a heavyweight process.

  1. Our highest priority is to satisfy the customer through early and continuous delivery of valuable software. The MIT Sloan Management Review published an analysis of software development practices that help companies build high-quality products.[1] The article found a number of practices that had a significant impact on the quality of the final system. One was a strong correlation between quality and the early delivery of a partially functioning system. The article reported that the less functional the initial delivery, the higher the quality in the final delivery. The article also found a strong correlation between final quality and frequent deliveries of increasing functionality. The more frequent the deliveries, the higher the final quality.

    [1] "Product-Development Practices That Work: How Internet Companies Build Software," MIT Sloan Management Review, Winter 2001, reprint number 4226.

    An agile set of practices delivers early and often. We strive to deliver a rudimentary system within the first few weeks of the start of the project. Thereafter, we strive to continue to deliver systems of increasing functionality every few weeks. Customers may choose to put these systems into production if they think that they are functional enough. Or, they may choose simply to review the existing functionality and report on changes they want made.

  2. Welcome changing requirements, even late in development. Agile processes harness change for the customer’s competitive advantage. This is a statement of attitude. The participants in an agile process are not afraid of change. They view changes to the requirements as good things, because those changes mean that the team has learned more about what it will take to satisfy the customer.

    An agile team works very hard to keep the structure of its software flexible, so that when requirements change, the impact to the system is minimal. Later in this book, we discuss the object-oriented design principles, patterns, and practices that help us to maintain this kind of flexibility.

  3. Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter time scale. We deliver working software, and we deliver it early and often. We are not content with delivering bundles of documents or plans. We don’t count those as true deliveries. Our eye is on the goal of delivering software that satisfies the customer’s needs.

  4. Businesspeople and developers must work together daily throughout the project. In order for a project to be agile, customers, developers, and stakeholders must have significant and frequent interaction. A software project is not like a fire-and-forget weapon. A software project must be continuously guided.

  5. Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done. People are the most important success factor. All other factorsprocess, environment, management, and so onare second-order factors and are subject to change if they are having an adverse effect on the people.

  6. The most efficient and effective method of conveying information to and within a development team is face-to-face conversation. In an agile project, people talk to one another. The primary mode of communication is human interaction. Written documents are created and updated incrementally on the same schedule as the software and only as needed.

  7. Working software is the primary measure of progress. Agile projects measure their progress by measuring the amount of software that is currently meeting the customer’s need. They don’t measure their progress in terms of the phase they are in or by the volume of documentation that has been produced or by the amount of infrastructure code they have created. They are 30 percent done when 30 percent of the necessary functionality is working.

  8. Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely. An agile project is not run like a 50-yard dash; it is run like a marathon. The team does not take off at full speed and try to maintain that speed for the duration. Rather, it runs at a fast but sustainable pace.

    Running too fast leads to burnout, shortcuts, and debacle. Agile teams pace themselves. They don’t allow themselves to get too tired. They don’t borrow tomorrow’s energy to get a bit more done today. They work at a rate that allows them to maintain the highest-quality standards for the duration of the project.

  9. Continuous attention to technical excellence and good design enhances agility. High quality is the key to high speed. The way to go fast is to keep the software as clean and robust as possible. Thus, all agile team members are committed to producing only the highest quality code they can. They do not make messes and then tell themselves that they’ll clean them up when they have more time. They clean any messes as they are made.

  10. Simplicitythe art of maximizing the amount of work not doneis essential. Agile teams do not try to build the grand system in the sky. Rather, they always take the simplest path that is consistent with their goals. They don’t put a lot of importance on anticipating tomorrow’s problems; nor do they try to defend against all of them today. Rather, they do the simplest and highest quality work today, confident that it will be easy to change if and when tomorrow’s problems arise.

  11. The best architectures, requirements, and designs emerge from self-organizing teams. An agile team is a self-organizing team. Responsibilities are not handed to individual team members from the outside but rather are communicated to the team as a whole. The team determines the best way to fulfill those responsibilities.

    Agile team members work together on all aspects of the project. Each member is allowed input into the whole. No single team member is solely responsible for the architecture or the requirements or the tests. The team shares those responsibilities, and each team member has influence over them.

  12. At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly. An agile team continually adjusts its organization, rules, conventions, relationships, and so on. An agile team knows that its environment is continuously changing and knows that it must change with that environment to remain agile.

Principles behind the Agile Manifesto

Manifesto for Agile Software Development

http://agilemanifesto.org/

We are uncovering better ways of developing
software by doing it and helping others do it.
Through this work we have come to value:

Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan

That is, while there is value in the items on
the right, we value the items on the left more.

Kent Beck
Mike Beedle
Arie van Bennekum
Alistair Cockburn
Ward Cunningham
Martin Fowler

James Grenning
Jim Highsmith
Andrew Hunt
Ron Jeffries
Jon Kern
Brian Marick

Robert C. Martin
Steve Mellor
Ken Schwaber
Jeff Sutherland
Dave Thomas
Manifesto for Agile Software Development

ABeam Core Value

Client Passion

We focus on our clients, always thinking in terms of what is best for each client. We offer only solutions that are workable, pragmatic and prudent—solutions that add value and become an intrinsic part of a client’s business.

Professional Excellence

Our solutions come from industry-specific knowledge, best practices and accumulated expertise. As a true industry leader, we constantly explore new services and expand our knowledge and skill sets. We invest in people who are passionate about achieving excellence, and who are measured by tangible results and client satisfaction.

Power of Diversity

As a global organization, we are diverse by definition. We share a culture of mutual respect for each individual’s capabilities, achievements, and heritage. We recognize how diversity adds value to our clients – and to each other – by amassing individuals’ capabilities into a unique collection of knowledge.

Collaboration and Collegiality

We work as a team, both enterprise-wide and at the engagement level, with our clients and with each other. We overcome complex challenges together, and welcome new challenges.

Global Perspective

We absorb best practices from around the world as our own, while respecting local value systems and cultures. This worldwide network enables us to deliver benefits that are specific to each client’s industry, objectives, and geography.

ABeam Core Value

UML diagrams

 
UML 2.0 has 13 types of diagrams that can be categorized hierarchically as shown in the following Class diagram:
Hierarchy of UML 2.0 Diagrams, shown as a class diagram
Structure diagrams emphasize what things must be in the system being modeled:

Behavior diagrams emphasize what must happen in the system being modeled:

Interaction diagrams, a subset of behavior diagrams, emphasize the flow of control and data among the things in the system being modeled:

The Protocol State Machine is a sub-variant of the State Machine. It may be used to model network communication protocols.

UML does not restrict UML element types to a certain diagram type. In general, every UML element may appear on almost all types of diagrams. This flexibility has been partially restricted in UML 2.0.

In keeping with the tradition of engineering drawings, a comment or note explaining usage, constraint, or intent is always allowed in a UML diagram.

UML diagrams

无题

去年请搬家公司搬家的时候,我和同学的电脑各被搬运工拔了一条内存条。我还记得当时,因为看那几位工人为了帮我们搬东西而汗流浃背,我和同学基本上加入了他们的工作,帮他们一起搬。没成想他们居然有这手。被人卖了还帮人数钱?苦笑。
 
前几天,发现住处附近的好德便利里面的阿姨,总是时不时地出错多收你两三块钱。一开始还以为他们是不小心出错,连续留心了两天后,发现那彻彻底底就是计划预谋好了的。我靠。
 
。。。
 
我这两天莫名地超级工作效率低下。姑且,将脑子里的脏东西往外倒一倒打发一下时间。
 
。。。
 
想不出题目,就叫无题吧。
无题

MSF Principles

  1. Foster open communication
  2. Work toward a shared vision
  3. Empower team members
  4. Establish clear accountability and shared responsibility
  5. Focus on delivering business value
  6. Stay agile, expect change
  7. Invest in quality
  8. Learn from all experiences

Just for a note…

MSF Principles