Lex Project
Effective Software

Basic Software Engineering

Software Engineering is the study of software cycles (design, development, implementation and maintenance). Learning Software Engineering is an essential step to prepare Computer Science students for their careers.

Why Software engineering?

  • Software ís an essential part in our modern world.
  • Software is usually complex, and requires involvements from several individuals.
  • Software engineering aims to create safe and reliable software systems.
  • Software engineering is a crucial key for the success of a company.
  • Software engineer is a well-paid job and has a bright career path.
  • Software continues to replace human in more and more aspects of our world.

Introduction

  1. Typical Software phases:
    • Requirement engineering
    • Design
    • Implementation
    • Verification and validation
    • Deploy
    • Maintenance
  2. Typical Software processes:

UML Diagram

UML diagram is a powerful tool to capture details of the system by provding visual expression of system contents and the relationships between them.
  1. Resources:
  2. Summary:
    • Use cases diagram: show use cases, actor and their relationship.
    • Class diagram: show the static relationship that exists among a group of classes or interfaces.

Git and GitHub

  1. Git:
    • Git is a version control system (VCS), which uses database to store all versions, and contain a stream of snapshots of the project.
    • Click here to see the life cycle of the status of your file
    • To get more understanding with git, practicing this exercise
  2. GitHub:
    GitHub is a popular website that hosts Git repositories online for people to collaborate. The website github.com is a perfect place for both students and developers.

Software Debugging

  1. Error, fault, failure:
    • Error: misunderstanding or misconceptions of programmers.
    • Fault (also called bug): The incorrect code.
    • Failure: The observable incorrect behavior of the software.
    • Error causes fault, fault causes failure.
  2. Debugging approaches: Once we have failure, we need to find a solution
    • Testing: run some input domain and compare the result to the expected output domain.
    • Static verification: similar to testing but you have to test all imput domain.
    • Inspection: Look at the code again to find any mistake.
    • Formal proof of correctness: proof to verify the expected result from the program.

Software Testing

  1. Overview:
    • Testing is an attempt to find mistakes in the code.
    • Testing successfully can avoids system failures, which may lead to disasters.
  2. Black-box testing:
    • focus on system behavior
    • do not deal with the code
    • often go along with boundary testing
  3. White-box testing:
    • focus on internal structure of the system
    • often go along with path testing

Software Refactoring

  1. Why refactoring?
    • Refactoring is a process of rewriting your program
    • Refactoring makes the code more understandable, reduces unnecessary code, adds comments, and alleviates the maintenance process
  2. When refactoring?
    • Duplicate codes
    • Long methods or long classes
    • Methods are not in suitable class
    • Lack of necessary comments
  3. How refactoring?
    • Method invocation
    • Inheritance
    • Delegation

Agile method

    Agile method is a software process, which is extremely effective for small team project. You can read more about agile method here
  1. Agile characteristics:
    • Agile uses the iterative approach
    • Each member is important for the project
    • Customers may also involve in the project
    • Requirements sometimes may change
    • Project is developed in a simple, but creative way
    • Communication plays a crucial role in the project
  2. Extreme programming:
    3. Extreme programming (also called XP) is a popular agile method. Practicing XP with the following steps:
    • Incremental planning: Have a careful plan to transform users requirement into appropriate software.
    • Small release: Release small parts with frequently changes to avoid time-wasting
    • Simple design: Design with as fewest methods and classes as possible
    • Test first: Unit Testing software is required
    • Refactoring: Refactoring make code readable and maintainable, which saves time and money
    • Pair programming: Two people working together can develop more reliable sotware products
    • Continuous integration: Integrate software every few hours to avoid uncontrollable software bugs
    • On-site customers: Customers are part of the team.
  3. Scrum:
    4. Scrum is another popular agile method. A scrum team often contains product owner, development team and scrum master.
    Learning more about Scrum with the following resources:

Resources

Here are a couple of useful online courses: