Rationalism In epistemology, rationalism is the view that "regards reason as the chief source and test of knowledge"[1] or "any view appealing to reason as a source of knowledge or justification".[2] More formally, rationalism is defined as a methodology or a theory "in which the criterion of the truth is not sensory but intellectual and deductive".[3] Rationalists believe reality has an intrinsically logical structure. Because of this, rationalists argue that certain truths exist and that the intellect can directly grasp these truths. That is to say, rationalists assert that certain rational principles exist in logic, mathematics, ethics, and metaphysics that are so fundamentally true that denying them causes one to fall into contradiction. Philosophical usage[edit] Rationalism is often contrasted with empiricism. Theory of justification[edit] The theory of justification is the part of epistemology that attempts to understand the justification of propositions and beliefs. The other two theses[edit]
Software development methodology A software development methodology or system development methodology in software engineering is a framework that is used to structure, plan, and control the process of developing an information system. Common methodologies include waterfall, prototyping, iterative and incremental development, spiral development, rapid application development, and extreme programming. A methodology can also include aspects of the development environment (i.e. History[edit] The software development methodology (also known as SDM) framework didn't emerge until the 1960s. As a framework[edit] A software development methodology is a framework that is used to structure, plan, and control the process of developing an information system - this includes the pre-definition of specific deliverables and artifacts that are created and completed by a project team to develop or maintain an application.[2] The three basic approaches applied to software development methodology frameworks. As an approach[edit] 1970s 1980s
Design More formally design has been defined as follows. Another definition for design is a roadmap or a strategic approach for someone to achieve a unique expectation. It defines the specifications, plans, parameters, costs, activities, processes and how and what to do within legal, political, social, environmental, safety and economic constraints in achieving that objective.[3] Here, a "specification" can be manifested as either a plan or a finished product, and "primitives" are the elements from which the design object is composed. With such a broad denotation, there is no universal language or unifying institution for designers of all disciplines. The person designing is called a designer, which is also a term used for people who work professionally in one of the various design areas, usually also specifying which area is being dealt with (such as a fashion designer, concept designer or web designer). Design as a process[edit] The Rational Model[edit] Example sequence of stages[edit] [edit]
Product family engineering Product family engineering (PFE), also known as product line engineering, is a synonym for "domain engineering" created by the Software Engineering Institute, a term coined by James Neighbors in his 1980 dissertation at University of California, Irvine. Software product lines are quite common in our daily lives, but before a product family can be successfully established, an extensive process has to be followed. This process is known as product family engineering. Product family engineering can be defined as a method that creates an underlying architecture of an organization's product platform. It provides an architecture that is based on commonality as well as planned variabilities. The various product variants can be derived from the basic product family, which creates the opportunity to reuse and differentiate on products in the family. Product family engineering is a relatively new approach to the creation of new products. Overall process[edit] Phase 1: product management[edit]
SOLID (object-oriented design) In computer programming, SOLID (Single responsibility, Open-closed, Liskov substitution, Interface segregation and Dependency inversion) is a mnemonic acronym introduced by Michael Feathers for the "first five principles" named by Robert C. Martin[1][2] in the early 2000s[3] that stands for five basic principles of object-oriented programming and design. The principles when applied together intend to make it more likely that a programmer will create a system that is easy to maintain and extend over time.[3] The principles of SOLID are guidelines that can be applied while working on software to remove code smells by causing the programmer to refactor the software's source code until it is both legible and extensible. It is part of an overall strategy of agile and adaptive programming.[3]
Responsibility-driven design Responsibility-driven design is a design technique in object-oriented programming. It was proposed by Rebecca Wirfs-Brock and Brian Wilkerson, who defined it as follows: Responsibility-driven design is inspired by the client/server model. Responsibility-driven design is in direct contrast with data-driven design, which promotes defining the behavior of a class along the data that it holds. The client/server model they refer to assumes that a software client and a software server exchange information based on a contract that both parties commit to adhere to. Building blocks[edit] In their book Object Design: Roles, Responsibilities and Collaborations,[1] the authors describe the following building blocks that make up responsibility-driven design. Application : A software application is referred to as a set of interacting objects[2]Candidates : Candidates or candidate objects are key concepts in the form of objects described on CRC cards. Objects[edit] Roles[edit] Control style[edit] None
Abstraction principle (computer programming) When read as recommendation to the programmer, the abstraction principle can be generalized as the "don't repeat yourself" principle, which recommends avoiding the duplication of information in general, and also avoiding the duplication of human effort involved in the software development process. As a recommendation to the programmer, in its formulation by Benjamin C. Pierce in Types and Programming Languages (2002), the abstraction principle reads (emphasis in original):[1] As a requirement of the programming language, in its formulation by David A. Under this very name, the abstraction principle appears into a long list of books. Alfred John Cole, Ronald Morrison (1982) An introduction to programming with S-algol: "[Abstraction] when applied to language design is to define all the semantically meaningful syntactic categories in the language and allow an abstraction over them".[3]Bruce J. Jump up ^ Pierce, Benjamin (2002).
Design by contract Approach for designing software Design by contract (DbC), also known as contract programming, programming by contract and design-by-contract programming, is an approach for designing software. The DbC approach assumes all client components that invoke an operation on a server component will meet the preconditions specified as required for that operation. Where this assumption is considered too risky (as in multi-channel or distributed computing), the inverse approach is taken, meaning that the server component tests that all relevant preconditions hold true (before, or while, processing the client component's request) and replies with a suitable error message if not. History[edit] Design by contract has its roots in work on formal verification, formal specification and Hoare logic. Description[edit] The central idea of DbC is a metaphor on how elements of a software system collaborate with each other on the basis of mutual obligations and benefits. What does the contract expect? Notes[edit]