Welcome to Introduction to Software Architecture. After watching this video, you will be able to: Describe what software architecture is; Explain the importance of well-designed software architecture; Explain how software architecture impacts design decisions such as tech stacks and production environments; and List several artifacts from software architecture design. Software design and documentation take place during the design phase of the SDLC. Software architecture, simply put, is the organization of the system. Software architecture serves as a blueprint for the software system that the programmers use to develop the interacting components of the software. The architecture comprises the fundamental structures of a software system and explains the behavior of that system. The architecture defines how components should interact with each other, the operating environment, and the principles used to design the software.
The software architecture captures early design decisions that are often costly to change once implemented. A software’s architecture addresses non-functional aspects of the application such as performance, scalability, maintainability, interoperability, security, and manageability. Well-designed software architecture is important for a number of reasons. First, it balances the differing needs of the stakeholders and serves as a basis for communication among team members. Next, the architecture represents the earliest design decisions, and those decisions conflate other coding implementation decisions later in the development process. Also, the well-designed architecture allows for agility due to changing requirements. A well-organized architecture increases the lifespan of the software system even when implementation details change.
Architectural design also guides the choice of technology stacks used for the system. Remember that architecture addresses non-functional capabilities so choosing stacks that address these requirements is paramount in the design phase. Recall that a tech stack is a list of all the technologies including software, programming languages, libraries, and frameworks that will be used to create the system. The architects must be aware of the stack’s advantages and disadvantages to anticipate development needs. Much like blueprints communicate design decisions to the builders of a house, there are also several artifacts produced during the architectural design phase that are used to communicate the software design to the stakeholders. These artifacts include a software design document, or SDD, an architectural diagram, and unified modeling language, or UML, diagrams. The SDD is a collection of technical specifications that indicate how the design should be implemented.
It provides a functional description of the software and design considerations such as assumptions, dependencies, constraints, requirements, objectives, and methodologies. The architectural diagram displays components, their interactions, their constraints, and their confines. It displays the architectural patterns used in the design. Architectural patterns are general, reusable solutions to commonly occurring problems and will be discussed in more detail in an upcoming video. UML diagrams are diagrams that communicate structure and behavior using common programming language agnostic notation. UML diagrams will also be discussed in more detail in another video. Another topic to be discussed in this module as it relates to software architecture includes production deployment considerations.
The architecture drives choices about the environment in which the software is released. The production environment is comprised of the infrastructure that runs and delivers the application to the end-user such as the servers, load balancers, and databases. In this video you learned that: Software architecture functions as a blueprint and represents the underlying organization of the application. A good architectural design is important because it serves as a basis for communication among team members. Software architecture represents the earliest design decisions, is hard to change once development starts, and accommodates changing requirements during development. Architectural design influences technology stack choices and the production environment and Artifacts resulting from the design include the SDD, the architecture diagra
Welcome to software design and modeling. After watching this video, you will be able to: Compare and contrast the terms “structured design” and “behavioral models.” Describe Unified Modeling Language (or UML) and its advantages when designing software. And, discuss the purpose of an interaction and a state transition diagram. Software Design is a process during which structural components and behavioral attributes of the software are documented before it can be developed. One of the key activities of the design process is modeling the software to express its design. This involves creating visual or diagrammatic representations of the bigger software solution, and its sub-components, as well as the interactions between them.
This can be done using simple flowcharts or more standardized methods like UML. A software system can be construed in terms of structural elements. Structured design conceptualizes a software problem into well-organized smaller solution elements called modules and sub-modules. Structured design stresses organization in order to achieve a solution. A well-structured design should contain modules that are cohesive and loosely coupled. Cohesion means that all functionally related elements are grouped together. Coupling is the communication between different modules. For a system to be loosely coupled the modules should be weakly associated so changes in one component have minimal effect on another. Loose coupling is an architectural principle often used in service-oriented architectures and microservices based architectural patterns, which will be discussed later in the module.
The diagram shows a simplified example billing system. Modules are arranged in a hierarchy and communicate with each other. The rectangles represent the modules and sub-modules. You can see that “billing” is the main module, and the other rectangles are sub-modules to the main billing module. In this example the sub-modules are “insurance verification,” “submit claim,” and “output total.” The arrows represent the flow of the data in the system. Behavioral models describe what a system does, without explaining how it does it.
The overall behavior of a system can be communicated through behavior models. There are a number of different UML diagrams that can be used to communicate the behavior of a system. We will discuss two such diagrams, a state transition diagram, and an interaction diagram. When developing a complex software system with interconnected modules, it can be difficult to remember the relationships, behaviors, and hierarchies among different elements. UML, which stands for Unified Modeling Language, is a way to visually represent the architecture, design, and implementation of complex software systems. UML is a standardized modeling language that can be used throughout development processes. UML diagrams can be divided into two classes: either structural or behavioral.
UML is programming language agnostic, so software developers can readily interpret and apply it to their work no matter which language they are developing in. There are several advantages of using UML to communicate architecture, behavior, and structure with development teams. The biggest advantage of UML diagrams is that they allow you to plan out features before any coding takes place which saves time and money. Secondly, the diagrams can be used to bring new team members or developers switching teams to get up to speed quickly. Also, the diagrams can be used to facilitate communication between technical and non-technical audiences more easily. And finally, having a visual representation of the system allows developers to navigate the source code because they can see the relationships among modules. So there are many types of UML diagrams but generally, UML diagrams can be classified as either behavioral or structural.
We will discuss behavioral models next and then object oriented-design. The behavior of a system can be explained and represented with the help of a UML diagram called a state transition diagram. The state transition diagram is a collection of states and events that describes the different states that a system has and the events which cause a change of state in the system. The diagram shown is an example of a state transition diagram that models a patient going to see a doctor at a clinic. The different states include “waiting,” “testing,” and “with the doctor.” The arrows represent possible transitions from one state to another and names the event that triggers the transition. An interaction diagram is used to model the dynamic nature of a software system. They help visualize objects and their relationships. A sequence diagram, which is the type of interaction diagram shown here, displays the communication between objects with respect to time. This example shows a patient making an appointment in an online portal. This is another example of a behavioral UML diagram.
In this video you learned that: Structured design breaks down a software problem into well-organized smaller solution elements. Behavioral models describe the behavior of the system without explaining how the system implements the behavior. Developing UML diagrams saves time and money by helping developers quickly get up to speed on a project, plan features in advance of coding, and help developers navigate source code easily. A state transition diagram is a behavioral model containing a collection of states and events that describe the different states of a system and the events which cause a change of state. And finally, an interaction diagram describes how interacting objects communicate.
Welcome to object-oriented analysis and design. After watching this video, you will be able to: Explain what objects and classes are. Describe the purpose of a class diagram, and explain object-oriented design in relation to software architecture. Object-oriented analysis and design, or OOAD for short, is an approach for analyzing and designing a software system when the system will use object-oriented programming languages to develop it. So, before we discuss OOAD, let’s learn a little more about object-oriented programming in languages like Java, C++, or Python. At the heart of OOAD are objects. Objects contain data, and they also have behaviors that prescribe the actions the object can take.
I could create an object for example, that represents a patient. And, let’s say the patient’s name is Naya Patel and Naya needs to cancel an appointment she made. Before creating Naya, however, we must first create a generic version of a patient object. The generic version of an object is called a “class”. Let’s discuss classes next before we discuss more about Naya. Specific objects, also called instances, are created from “classes” which are blueprints or templates for an object. So, from our previous example, considering Naya Patel, Naya would be an instance of the patient class.
The class contains the object’s generic attributes – the properties and methods – but it is only when the object is created, which is called “instantiation,” inside the code that these generic attributes are set to particular values. So, the patient class might have a variable called LastName, which is a property but does not specify what that last name is. LastName is just a placeholder until the object is created and assigned a name. And once the object has been instantiated its methods can be called to make the object perform some action such as making or canceling an appointment. OOAD is used for a system that can be broken down into objects that interact with each other. In this way, multiple developers can work on different aspects of the application at the same time. As noted earlier, visual UML diagrams can be created that show both the static structure and dynamic behavior of a system.
We’ve seen a couple of examples of behavioral UML diagrams already, so now let’s look at a structural UML diagram called a “class diagram” next now that we know what classes are. This is an example of a “class diagram.” Class diagrams are commonly used to communicate a software system’s structure in OOAD. The class diagram shows how the classes in an object-oriented design relate to one another. Each box represents a class and shows its attributes. Recall that an object’s attributes are both its properties or its data, and its available actions, called methods. A class diagram also shows the relationships between classes.
A subclass is said to “inherit” its parent class attributes meaning it has the same properties and methods as the parent class but also may add additional properties and methods. In this diagram, the nurse, doctor, and technician classes are subclasses of medical personnel, and the specialist class is a subclass of the doctor class. This means that doctors can do anything medical personnel can do and specialists can do anything a doctor can do. In this video you learned that: Object-oriented analysis and design is the process of planning a software system based on the behaviors of interacting objects. Objects contain data, and they also have behaviors that prescribe the actions the object can take. Classes are blueprints for objects. And a class diagram is a structural UML diagram that shows the relationship between objects.
Welcome to Insiders' Viewpoints: The Importance of Design and Software Architecture. In this video, we will hear from experts discussing the importance of design and software architecture in a software engineering project. Design and architecture are crucial. If you don't know where you're going, how do you know what you need to do now? You always need to know what you should, what your program needs to be prepared to handle, and the system that it's operating within. If you are running a series, if you're running a bunch of applications that are all co-hosted on the same server, you can make certain assumptions about the ways those services can interact with each other that do not hold. I also sometimes think of architecture and orchestration.
So you can you can have like a beautiful, really nice sounding instrument. But if it's not in sync with the rest of the orchestra, it's going to sound like a complete cacophonous mess in the end. So you really need to think about the bigger picture. Sustainability, whether you're, you know, what you're building actually makes sense in the larger sort of ecosystem. And every time if you spend the time to write your code, and then you figure out why it doesn't work, you've wasted a lot of time writing that code, maybe you've learned some things, it's not a total waste. But you've spent a lot of time that could have been spent moving forward. And so if you can think about those things ahead of time on a project.
And then when you write your code, you're reasonably sure that the code you write is actually going to persist and get used, that's generally speaking a better place to be in. So architecture is very important. like there's a lot of talk about its scale, global availability, often something you build would work very well in a very hyper local environment, but not work well, when it's expected to be used across the globe or, you know, works well for one user, but doesn't work well, for a million users. I'm building a service, I need XYZ pieces of data to come into the function that I want to write. Where are those things coming from? How are they getting passed in? Once I have them what do I need to do with them? What else needs to access this data?
And how am I going to get the data to those other parts also? If you don't have those questions answered, you end up writing a lot of churny code. If everything is on a separate server somewhere in the cloud, or separate physical servers that are just located somewhere different inside your data center, then you have to incur a network hop to go over them. And that takes time, your page might start timing out and your customers might get really upset at you for how long things take. And so, if you're building something in like a microservice architecture, the way that you load your data becomes much more important than if everything is hosted together on the same server. But maybe the question of who is using my service? How do I know who you are?
That can become an interesting question, depending on where your servers where your services are running, and what mechanisms are available to you to identify people. If your people if you want your customers to log into a website, how are you doing account management? How do you know who that person is and what they're allowed to do? Or if you have multiple services talking to each other again, how do you know what that service is? What it's allowed to do? How do you make the call between one and the other? How do you transmit data between different parts of your stack?
So architecture is very important. It doesn't always have to be super well defined, super strictly defined, but you need to have some idea of what what things do you need, roughly where they're going to live. And what things what are they responsible for? Those would probably be the three big questions to ask, what, where and scope of them? So these sorts of concepts, you know, you have to think about those things. When you're designing or architecting a system, you're thinking like, 5, 10 years ahead to when you're thinking about architecture and design, you're not thinking about just building something quickly, in getting it up, you actually want to plan ahead. So I think a lot of architecture and design is thinking about, you know, how the how many steps, how many years, whatever in the future, you know, what is it going to look like then?
What do you need to do to keep growing the system and evolving it? Because you know, you don't want to make gigantic architecture changes that often, you know, you don't really use when buildings are repaired, they there's like, tiny bits of things get repaired. And then at some point, you tear the thing down and rebuild it. And I think that's a similar model applied to sustainable system architecture, you don't want to re-architect and redesign every few years, you want it to last as long as you possibly can.
아직 댓글이 없습니다.
로그인 후 댓글을 남길 수 있어요