Mythical Man-Month Analysis

--Originally published at That Class Blog

Well. What I’ve learned from this book, in fact, it’s stated from the start (I don’t remember at which point exactly, but I think it was in the beginning chapters); It’s that there isn’t a thing that causes problems and delays, there isn’t a specific thing that the book, the teacher or anybody else can tell you and warn you about at the moment when you become a software manager, or project owner, or developer.

Things just happen. A lot of them. At the start it’s just something simple, maybe something that no one thought that it could evolve to something else. Then another thing appears, now you notice but you don’t react immediately, and then another, and another, while the progress keeps getting slower and slower. And then the morale gets lower, and the performance too, and the client gets mad.

It’s a sad and stressful path. And there really isn’t something that you could know it will happen in every project. But you can try to prevent, everything, and make plans for every scenario if it comes to be, even if at the end the project goes very well.

And this is what the rest of the book is about. What is to really manage a software project and everything you can do when assuming such position. Either as a manager for the architects or a manager for the implementers, or general manager.

A basic concept for a good project to try to get to the end is communication. There is no chapter in the book where this capacity isn’t mentioned. It’s very important. At first level, there needs to be a very good communication between the architects and the implementers’ representatives. This is essential because the implementer will try to keep the architect from the skies and

Continue reading "Mythical Man-Month Analysis"

Ted-Talks Opinion

--Originally published at That Class Blog

Let’s talk first about the talk given by Sam Richards, the one about empathy.

I liked his example, putting the US in a position like the one they make other countries be when a society or a regime gets in between a resource and the US. It’s not right, and it’s even worse when the US citizens know about how are the foreign people treated by their army, by their governments that will do anything to their citizens if the US helps them to stay in power… And won’t do anything. That’s wrong. People should at least acknowledge that what they are doing is wrong. That people are getting killed, innocent people, to maintain the American economic lifestyle.

We often forget to ask who is really paying for our comfortable way of life. And if we did that more often, and put ourselves in the shoes of the people who are paying, with their lives, not just with money for the bills. They are suffering! They are dying! Their houses are bombed every day! From their government, from other nations, from the terrorists, from whoever. And the innocents, they don’t support the terrorists, they don’t support the regime, and still, they are paying the hard bills for us.

At the end, when using empathy, we allow ourselves to see the big picture and understand the other’s perspective. In the experiment Sam Richard does, we understand how a regular person, a regular Muslim, with a regular family, who live on a regular street in Syria, Iran, Irak, Afghanistan or wherever people are being subjugated to the other’s will sees the conflict. And Sam doesn’t ask you to change your perspective, but to understand theirs.

And as I have experienced, if you understand the other party perspective, it’s more probable to solve

Continue reading "Ted-Talks Opinion"

2 of Plato’s regimes – MMM Ch. 4

--Originally published at That Class Blog

Conceptual integrity is to maintain the good initial ideas, even if it implies not making that many features. This is better than having lots of uncoordinated ideas.

Likewise, functionality and simplicity. Which is better? There have been software projects that have an outstanding performance in one of both.  But we have to say that it’s a combination of simplicity and straightforwardness. Every part must use the same philosophies, same semantics and syntax and the, you have conceptual integrity.

And how, or more precisely, who will achieve that integrity? Either one mind (Surgical team), the equivalent to an aristocracy; or a handful of minds, with a division of architecture and implementation, the equivalent to a democracy.

And it’s no bad to desire a democracy, but it has several problems. The people in charge of the architecture should consider methods to implement their architecture; the implementers, when suggesting ideas must preserve the integrity of the architects.
That’s why at the end, the aristocracy (Surgical team) is better because as long as the design and implementation are clear in the surgeon’s mind, everything is ok. Or at least, an aristocracy of architects, who have a clear idea of how the system should behave, and they should decide how to maintain integrity, even if that means to leave the implementers with practically no voice, at the end, what must endure the most is the design, not the implementation.

Using CC (BY-SA). Published by Jocelyn Kinghorn. From


The Surgical Team – MMM Ch. 3

--Originally published at That Class Blog

The dream: To develop a project with a small team you can know, and trust in their abilities. Forget the big teams, integrated by mediocre developers. In fact, by spending the double on a very good programmer, 10 times the performance could be expected. We can do this all by ourselves. Ah… The dream…

The reality: Big and complex problems need to be done and big teams are needed to do this.

How? Harlan Mills offers a solution. To make several teams, where only one member of each attacks the problem, and the rest only assist him in achieving maximum productivity. You keep a few number of people in the building design, but a lot of them in the actual construction. Just like a surgical team.

Here are the roles of this approach:

  • The surgeon: Define functional and performance specification. Designs, codes, tests the program and writes its documentation.
  • The copilot: Is a less-experienced surgeon. He advises the surgeon, and he can listen to him, or not. He knows the code perfectly but isn’t responsible for it.
  • The administrator: Even though the surgeon is the boss, he needs someone to be in charge of his administrative (Money, personnel, machines…) decisions. The administrator can serve 2 teams.
  • The editor: He writes the external and internal documentation. He reworks the draft of the surgeon.
  • Two secretaries: One for the administrator and the other one for the editor.
  • The program clerk:  He is in charge of the maintenance of the machine and user readable files.
  • The toolsmith: File, text and debugging services. Made fast and with quality
  • The tester: Design test cases and data.
  • The language lawyer: Master of the language selected for development. Can work with 2 or 3 surgeons.

Because the purpose of this team organization such that everyone is represented

Continue reading "The Surgical Team – MMM Ch. 3"

Building the software: Ch. 10 SG

--Originally published at That Class Blog

Software architecture provides the technical structure for a project. The time in which the software is mapped to diagrams and prototypes, and the program is partitioned into systems and subsystems.
Everything is described in the software architecture document, that contains the software organization, support for changes, reuse or purchase of components, and design of functionalities.

This document has the following categories:

  • System Overview: Describe the system in general terms. Help build the developer the idea of what is he going to build. As well as a description of the design alternatives that were considered, and why were or weren’t chosen.
  • Conceptual Integrity: Descriptions and diagrams of the almost obvious solution to the problem. Simple, short, and easy.
  • Subsystems and Organization: Here the major clusters of functionality must be defined (Output formatting, data storage, analysis, user input…). Usually a complete system hast five to nine subsystems. The responsibilities of each subsystem are stated, and how are they intercommunicated and restricted.
  • Notation: Describe the notation that will be used for the pseudocode and diagrams (Such as UML)
  • Change Scenarios and Change Strategy: List what parts of the software will need (Most likely) to be changed, and how the team must approach this changes.
  • Reuse Analysis and Build vs. Build Decisions: Define what components are going to be developed from scratch, reused (If available) or bought.
  • Approach to Standard Functional Areas: Functional areas that the architecture must address:
    • External software interfaces: How is the software expected to communicate with other software.
    • User interfaces: How is it isolated, so that the changes made to the interface won’t affect to the system (And reverse).
    • Database organization: Organization and content of the DB.
    • Data storage: Major data structures and what isn’t stored in the DB.
    • Key algorithms: Defined, or for later definition.
    • Memory management: Allocation of
      Continue reading "Building the software: Ch. 10 SG"

Quality Meter: Ch. 9 SG

--Originally published at That Class Blog

Let’s do this fast folks, because this chapter was looooooooong.

So, first things first. What is quality? We have to thank McConnel for this simple definition: “the degree to which the software satisfies both stated and implied requirements”. Easy to understand. Perfect.

But why is this important? Because keeping defects controlled affects the development speed, cost and characteristics. A delivered low-quality software increases the cost of end-user support, among other things. McConnel emphasizes in remembering that the end-user tends to forget the delivery time of the software, but not if they liked using it. They forgive taking even taking more time than expected if they will enjoy using the software.

And how to keep the quality up at all times? Using the Quality Assurance Plan. The team must commit to the QA Plan. The activities of the QA must be planed and committed to writing, the QA must be established at least at the same time as the project requirements, a group that will take care of the quality must exist, with capable people, and finally, all the QA activities must be well funded.

And which activities conform the QA Plan?

  • Defect Tracking: Keep record of every defect that is found during development. The moment of detection, and the moment where the defect was resolved (And how). Its important to keep the information public, so the team can adjust the estimates, and see progress.
  • Unit Testing: Testing made by the developer who wrote the code. The unit can refer to any programming entity. It’s informal.
  • Source-Code Tracing: Carried out also by the person who wrote the code. Consist in going through the code, line-by-line, using a debugger.
  • Technical Reviews: This are reviews made by the peers of the code author. Usually are given by the full team, and the QA
    Continue reading "Quality Meter: Ch. 9 SG"