Why do software projects fail so often?

Why do software projects fails?

1.Lack of User Inputs
2.Incomplete Requirements & Specifications
3.Changing Requirements & Specifications
4.Lack of Executive Support
5.Technology Incompetence
6.Lack of Resources
7.Unrealistic Expectations
8.Unclear Objectives
9.Unrealistic Time Frames
10.New Technology

What can we do to make them succeed?

1.User Involvement
2.Executive Management Support
3.Clear Statement of Requirements
4.Proper Planning
5.Realistic Expectations
6.Smaller Project Milestones
7.Competent Staff
8.Ownership
9.Clear Vision & Objectives
10.Hardworking, Focused Staff

What is the importance of software project management?

1.Identify the scope of the project
2.Estimatethe work involved
3.Create a project schedule
4.Keep the team and management up to date on the project's progress
5.Identify software requirements
6.Avoiding the risk

Reference Websites:
http://en.wikipedia.org/wiki/Software_project_management

What is test-driven development?

What is the main idea of test-driven development?

Test-driven development (TDD) , is an evolutionary approach to development which combines test-first development where you write a test before you write just enough production code to fulfill that test and refactoring.

What is the goal of test-driven development?

One view is the goal of TDD is specification and not validation. In other words, it’s one way to think through your design before your write your functional code. Another view is that TDD is a programming technique. As Ron Jeffries likes to say, the goal of TDD is to write clean code that works.

How does a test-driven development cycle look like?

1. Write the testIt begins with writing a test. In order to write a test, the developer must understand the specification and the requirements clearly. This is accomplished through use cases and user stories. The design document covers all the test scenarios and exception conditions.

2. Write the codeThe next step is to make the test pass by writing the code. This step forces the programmer to take the perspective of a client by seeing the code through its interfaces. This is the design driven part of test-driven development. As part of test calibration, your code should fail the test meaningfully the first time around.

3. Run the automated testsThe next step is to run the automated test cases and observe if they pass or fail. If they pass, the programmer can be guaranteed that the code meets the test cases as written. If there are failures, the code did not meet the test cases.

4. RefactorThe final step is the refactoring step and any code clean-up necessary will occur here. The test cases are then re-run and observed.

5. RepeatThe cycle will then repeat itself and start with either adding additional functionality or fixing any errors

http://www.agiledata.org/essays/tdd.html#WhatIsTDD
http://en.wikipedia.org/wiki/Test-driven_development

Software Design Patterns: How much do you understand?

The Adapter Design Pattern - is a type of design pattern that is used for converting the interface of a class into an interface that its clients expect to see. This pattern allows incompatible interfaces to work together.

The Bridge Design Pattern - separates an abstract interface from its implementation so that both the interface and its implementation can change without any dependancy between each other.

The Composite Design Pattern - is used to compose objects so that they can be represented in part-whole hierarchies in tree-structures. This pattern allows clients to treat individual objects equally.

http://my.execpc.com/~gopalan/design/structural.html

Stuff that lets agile software developers show off what they believe in

"YAGNI"

In software engineering, YAGNI, short for 'You Ain't Gonna Need It', is a reminder for programmers that one should never add functionality until it is necessary. The temptation to write code to that is not necessary at the moment, but is perceived to be necessary in the future, has some overlooked disadvantages:


1. Delays what the programmer was originally working on.

2. There is a chance that the requirements for the software will change and the functionality will become either different or unneeded. By applying the YAGNI principle, the programmer has not wasted time in adding the redundant functionality and no longer has to waste additional time debugging the code. The code is also less cluttered as a result.

Reference websites:
http://en.wikipedia.org/wiki/YAGNI

"DTSTTCPW"

Do the simplest thing that could possibly work (DTSTTCPW) means you implement the first idea that comes to mind. This can be scary. Rely on your courage to try out the idea. Remember that failure is an important part of creation. It is unlikely the simplest idea is what you will end up with. However, it's also unlikely you can anticipate what's wrong with your simple solution until you try it out. Let the feedback system guide your implementation. DTSTTCPW is simplicity as in fast and easy.

Reference websites:
http://www.extremeperl.org/bk/extreme-programming

Software Engineering Certification Programs: What Can You Learn from Them?

I found out the following from the CSDP program which not included in our textbook:

1. Engineering Economics
2. Ethics
3. Professional Practice
4. Standards
5. Software Design Quality Analysis and Evaluation
6. Software and System Safety
7. Software Maintainability
8. Software Maintenance Process
9. Software Maintenance Measurement
10. Software Maintenance Planning
11. Software Maintenance Management
12. Software Maintenance Documentation

It is difficult to find out them which is easier to know the different between them.

The attributes of make a program code be good

1. should be simply.
2. should be easy to understand.
3. should be stable and reliable.
4. should be add the command in the program.

My favorite UML Tools

I have tried the Poseidon for UML Community Edition and Visual Paradigm for UML Community Edition. I think my favorite UML tool is Poseidon for UML Community Edition.

Visual Paradigm for UML Community Edition have a very colorful user interface, but i think that is difficult to me. So i prefer to use Poseidon for UML Community Edition. Its user interface is quite colorful but it is easier to use than Visual Paradigm for UML Community Edition.

Basic skills for software engineers

Software engineers needs:
1) Analyze users needs
2) Design, construct, test, and maintain computer applications software or systems.
3) Solve technical problems
4) Strong programming skills
5) More concerned with developing algorithms and analyzing and solving programming problems.

第一篇文章的由來...........?!

因為自己個web space既database發生錯誤 , 經過web space service公司搶救無效 , 舊blog既文章完全無曬 , 同時舊blog宣佈死亡 !! 為免同樣事情再次發生 , 唯有o係Blogger到開一個新既blog啦~~