Después de un semestre de clase con Ken Bauer puedo decir que agradezco mucho haber llevado esta materia con él y con sus métodos de enseñanza. Algo que me pareció sumamente importante fue que a Ken realmente le encanta dar clases, es su pasión y cada día se esfuerza en ser un mejor maestro. Esta cualidad hace que sus clases sean dinámicas y nosotros como alumnos queramos ir a su clase.
High quality software helps developers create maintainable software.
Maintenance should be taken into consideration to help software become and stay operational, it involves things like code changes (to eliminate bugs and problems), configuration changes (to control and update software behavior) and environmental changes (operating environment).
There are many reasons why software maintenance is important like the market conditions, client requirements, host modifications and organization changes. For these reasons there are different types of maintenance:
-Corrective Maintenance: Fix problems discovered by end users.
-Adaptive Maintenance: Modify the SW to keep up to date.
-Perfective Maintenance: Keep the SW usable over a long period of time.
-Preventive Maintenance: Update to prevent future problems.
This part of the SDLC is quite costly and can sometimes cost as high as 67% of the whole software process lifecycle. This cost is so high because of many factors like: software life time, undocumented changes, changes that hurt the original software, structure of the program, programming language, external environment.
Maintenance Activities are Categorized into:
Identification & Tracing
Open Source Software is an amazing new form of spreading knowledge, it is generally free software that can be used in any business. Developers of open source are people that choose to distribute their code publicly and make it available for anyone to use, as long as the users give credit back to the original developer, they can view and edit the original code in any way they want.
It works in mostly the same way as paid software, you get a license, you just don’t pay for it.
There is a great philosophy behind open source, users are basically co-developers because they can suggest their own ideas to improve the code and customize programs to their own needs and expectations.
Well first of all it is free, and who doesn’t like free stuff? Open software is a great way for businesses to save money and there are unlimited possibilities for growth because of its evolving nature and quality is always improving because of the multiple developers that can input their knowledge and share it with others. It is also great to be able to adapt to any businesses specific requirements.
A few Disadvantages:
Because of the lack of commercial products, some open source software has become targeted for developers only, and doesn’t get much attention from non-developers that could potentially use the software because of the programs forgetting to be “user-friendly” and user interfaces are not really developed.
Another thing is that when things go wrong it is very hard to search for help because of the constantly changing nature and reliability on certain developers.
Also, everyone being able to edit the source code is quite insecure because anyone with bad intentions can edit the code and exploit potential vulnerabilities.
On an end note, open source software Continue reading "Sharing is Caring:)"
There has to always be a business justification, if a company is going to spend a lot of money they must have a need for software, so first of all the software has to have a solid value proposition, so there should be a gain or benefit because of its use:
ROI = (GAIN FROM INVESTMENT-COST OF INVESTMENT)/COST OF INVESTMENT
A business implements a software and all of the stakeholders or trading partners use the software you will have a higher Return on Investment.
Vendor election is very important for a business because the software success will depend largely on the maintenance and installation process a company gives them , that is why installation and change must be very swift and not cause stress for the business and their employees.
To make sure that a project is executed according to plan there must be a set governance structure, this enables people to be able to hold themselves and other accountable for problems that might occur during the implementation process.
When a software will be upgraded or a new software will be implemented many problems emerge because people are already used to what they have and many people suffer from fear of change.
Because of this fear of change, people don’t pay attention to the training and then businesses spend a lot of money on things that will then not be used, not because of the SW not working properly or not being good enough but because employees in a company did not pay attention to the training and do not know how to use the new systems.
A lot of info may be lost or repeated when software is changed, you need to check for the info not to be repeated or erased. So when the system is implemented, it Continue reading "What to consider when implementing software"
Software testing is a phase of the Software Development Life Cycle that focuses on executing a program and finding bugs. The process should validate and verify that the program meets the functional and non-functional requirements gathered in the first stage of the process.
During testing, the developers should find out if the program meets the technical and business needs that should have guided the design and coding phases. The program should work the way it was expected to and should be able to be implemented in the next stage.
Testing can be done as a process rather that a unique activity. It should take place during the whole software life cycle in small steps, to prevent defects in the code and to verify that the design is being implemented correctly.
Testing must be planned so reports and progress can be documented and the status of a program can be defined and updated. Preparations must be made by selecting conditions and designing test cases.
Static testing can be done without executing the code and it is used to verify the source code and static analysis.
Dynamic testing is done when the code is executed so results can be demonstrated. It is done during validation, some examples are unit testing, integration testing and system testing.
Uploaded by Guru99
Evaluations must be done during the testing phase to check that the needed criteria was met and whether the software passes the needed tests and can now be launched.
Software testing is a necessary part of software development because everyone makes mistakes (we are human after all) and they should be corrected because they may lead to unnecessary risks and expensive corrections. It is good to have someone else check these mistakes because they are more likely to spot these mistakes than the original
Design patterns are a great solution to common problems during software design . These patterns aren’t a finished design that can be directly transformed into code but a sort of template one can use to solve a problem that can be applied and customized to specific situations.
Design Patterns help speed up the development process because they provide tested development paradigms, they provide solutions for issues that are not always visible at the beginning of the development process, sometimes these issues are only visible when the projects are implemented, this makes patterns a great way to avoid certain risks during and after the Software Development Life Cycle.
Patterns are based on iteration, so code can be reused to improve readability and understandability of the program in general, to avoid problems by providing general solutions that are documented.
There are three main design pattern types:
-Creational Design Patterns
These are mostly about instantiation and the creation of classes and objects by using inheritance and delegation effectively & efficiently.
Here are some examples:
• Abstract Factory
• Factory Method
• Object Pool
-Structural Design Patterns
These patterns are about pattern composition and structure so functional interfaces can be composed.
Here are some examples:
• Private Class Data
-Behavioral Design Patterns
These are patterns centered on object communication between objects.
• Chain of Responsibility
• Null Object
• Template Method
Software Design focuses on the way internal modules or components of a system interact with each other so it is not the same thing as Software Architecture. This the “how” phase of the Software Development Life Cycle.
This process transforms the user requirements into a developer friendly understandable and specific format that the programmer(s) can later code and implement.
An SRS (Software Requirement Specification) document should be created to assess user requirements, and the design phase finds a solution to the problems planted during the requirement gathering phase.
There are several design levels to be considered:
-Architectural Design: highest level of abstraction or a general blueprint.
-High-Level Design: a less abstracted view that focuses on how the components of a system can be implemented in modules.
-Detailed Design: Detailed designs of systems and subsystems that defines a logical structure for each module and the communication interfaces.
Some keys for good software design are:
-Modularization: Often used as a technique to divide a software system into many small segments called modules that should carry out independent tasks.
-Concurrency: Changing sequential execution into concurrent means splitting the software into independent modules that can be executed in parallel.
-Coupling: a measure for defining the level of inter-dependability between modules, for example: content, common, control, stamp and data.
-Cohesion: A measure for defining the intra-dependability of the elements of a module, for example: co-incidental, logical, temporal, procedural, etc.
Software architecture (not to be confused with architecture design) is mostly the externally visible components of a system.
In this phase of the Software Development Life Cycle the main concern is “what” a system should do while software Design is about “how” a system achieves its goals.
Architecture is a higher level of abstraction and it scopes all of the system, not just the modules like in the design.
Architecture is the blueprint for building the design, it aids in understanding how a certain system must behave, it must meet the technical and operational requirements. The structural elements and interfaces of the system are selected to compose the project and they are separated into modules that must later be designed.
Architecture is important because all software must have solid foundations. Common problems or failures must be detected so long term consequences can be avoided.
There are some key things to consider when building a systems architecture:
Here is a video to understand the difference between software design and architecture:
Uploaded by Software Architect CA
Some software architecture styles are:
-Structure (component-based, layered)
-Shared Memory (data-centric, rule-based)
-Messaging (event-driven, asynchronous messaging)
-Adaptive Systems (plug-ins, Microkernel, reflection)
-Distributed Systems (2-tier, 3-tier, n-tier, peer2peer)
The Unified Modeling Language or UML for short is a standard graphical notation that is made up of sets of diagrams that illustrate what the software architecture of a certain system looks like, it is easy to read so any developer can take a look at it and have a basic understanding of the project.
The design and structure of the system is modeled with UML, it can be applied to any kind of application, independently of the platform used to build it, it is a tool that helps manage large and complex systems because it brings a clearly visible structure to the architecture and design.
UML’s main purpose it to have a stable and common design language so applications can be build and analyzed by other developers, it is a sort of blueprint to software design and architecture.
One uf the main features is the use-case diagram:
It helps development teams visalize what the functional requirements of a system are and how they are related to each other.
The first step of the Software Development Lifecycle is Functional & non Functional Requirement Gathering , it is the result from the specification of the informal ideas a client has about a product. The goals of this phase are to define the needed software and hardware. It is a really important phase because failures at this stage may increase the cost of development in higher stages to ensure the customer needs.
There are two factors to consider:
Initial Input: The idea of how a system will be created considering the needs of the client and defining a problem to be solved.
Desired Output: The requirements must be as specific as possible so the problem that needs to be solved can be completely understood.
Requirements Elicitation is mainly understanding and analyzing all of the requirements a client has for a system. Developers & engineers work closely with clients to understand the problems that need to be solved and what functionality a system should have and what hardware is optimal.
The problem is that clients usually do not have a clear idea of what they want or need and if there are many stakeholders, they will most surely have conflicting ideas. The conditions need to be met for the client to be able to solve a specific problem or achieve a certain objective and it must satisfy specific contracts, standards and specifications.
Requirements Elicitation – basic customer idea and definition.
Requirements Specification – Basic developer design and technical specifications.
Requirement analysis normaly uses one of two models: Dynamic model or Object Model. These specifications use formal (exact mathematical syntax or semanic syntax) or semi-formal notation (like UML).
In general this is a phase of understanding the stated problem that the client has and how it should be Continue reading "Essentials of Elicitation & Specification"