The idea of instances and objects in computing made its first significant breakthrough in the PDP-1 system at MIT that was possibly the first instance of architecture based on capability. The concept of objects as programming entities was first introduced in the 1960s with Simula 67, a programming language that was designed to make simulations. The language was created by Ole-Johan Dahl and Kristen Nygaard of the Norwegian Computing Center in Oslo. George T. Heinemann and William T. (2001).
The concept was born to organize the various types of ships into distinct categories of objects (each category of objects accountable for their own behavior and data.) This was a straightforward extension of concepts previously used in programming analog. In analog computers, this direct mapping from real-world objects to analog phenomenon objects (and in turn) is (and is) known as'simulation'. Simula did not just introduce the notion of classes but also the instances that belong to classes. This was probably the first instance of explicit use of the concepts. George T. Heinemann and William T. (2001).
It was the Smalltalk language, created at Xerox PARC during the 1970s, was the first language to use the concept of Object-oriented programming to refer to the ubiquitous use of messages and objects as the base for computation. Smalltalk designers were heavily influenced concepts that were introduced within Simula 67, however Smalltalk was developed to be a dynamic system, where classes could be designed and changed dynamically instead of just using static classes as in Simula. The concepts of Simula 67 were also used in different languages, ranging from the variants that derived from Lisp up to Pascal. Object-oriented programming became the predominant programming technique in the late 1990s, in large part because of its influence on C++. George T. Heinemann and William T. (2001).
This dominance has been strengthened due to the growing popularity of GUIs and for which OOP programming is perfectly suited. A good example of a similar interactive GUI program and OOP language is available inside the Cocoa frameworks for Mac OS X, written in Objective C, an object-oriented interactive extension of the messaging language C built on Smalltalk. OOP toolkits have also helped to increase the appeal that event-driven programming has gained (although this notion isn't only limited only to OOP).
A few believe that the connection to GUIs (real or imagined) was the catalyst that brought OOP into the mainstream of programming. In ETH Z, Niklaus Wirth along with his colleagues had investigated topics like modular programming and data abstraction. Modula-2 incorporated both of these, as did their follow-up version, Oberon, included a distinct approach to object orientation classes, and these object-oriented functions have been introduced to numerous languages in the past which included Ada, BASIC, Lisp, FORTRAN, Pascal, and many more. Incorporating these features into languages that weren't originally developed for them usually caused problems with maintainability and compatibility of the code. Mira Mezini and Klaus Ostermann (2002).
In the last decade, Java has seen a surge in popularity partly because of its similarities to C and C++ However, most importantly, it is due to its use of virtual machines that are designed to run code in a consistent manner on a wide range of platforms. This makes it extremely appealing to large-scale development firms with diverse environments. Microsoft's.NET initiative is based on the same purpose and is able to support a number of new languages or variations of the older ones. In recent times, a range of new languages have been developed which are primarily object-oriented but compatible with procedural methods for example, Python or Ruby.
In addition to Java as the other major language, perhaps the most important commercially-important modern object-oriented software are Microsoft Visual Basic.NET and C# designed for Microsoft's.NET platform. Similar to how procedural programming brought about refinements to techniques like structured programming , today's design methodologies for software that are object-oriented incorporate refinements like the use of design patterns, design by contract, and modelling the use of languages (such like UML ). Mira Mezini and Klaus Ostermann (2002).
Object-oriented programming's roots go all the way in the 60s. When software and hardware were becoming more complicated researchers looked at ways in which the quality of software could be preserved. Object-oriented programming was introduced in part to try to tackle this issue by focusing on distinct units of programming logic and re-usability of software. This Similar programming language was among the first one to introduce the fundamental concepts behind the concept of object-oriented programming (objects classes, classes, subclasses coroutines, virtual methods garbage collection and discrete simulation of events) as a subset of Algol.
Simula was a popular choice for physical modeling, like models that study and improve the speed of ships as well as their cargo through ports of entry. Smalltalk was the initial programming language that was described as "object-oriented". Object-oriented programming can be viewed as a set of cooperating objects, in contrast to a conventional view where a program could be viewed as a collection of computer-generated tasks ("subroutines ").
In OOP every object is in a position to process messages, receive data and transmitting messages and data to the other objects. Each object is viewed as a distinct machine, with its own purpose or obligation. Its actions, (or "operators " of the object are closely linked to the object. For instance in OOP the data structures are likely to carry their own operators along with them (or at the very least "inherit" their operations from an identical item (or "class"). The conventional approach is to look at the behavior and data separately. White Paper, Microsoft Corporation, 2001.
Development of applications within the realm of component development is comprised of three types of development: creating and developing components, and creating applications. The latter is the most important, creating application components and applications with a component framework as well as the existing components. Mira Mezini and Klaus Ostermann (2002).
The process of designing a quality component requires contemplating a number of aspects, including the right encapsulation method, clear interfaces, functional granularity that is appropriate an appropriate balance of specificity and reusability, as well as full coverage of functionality. The designers responsible for developing components must be aware of the framework of the component and the necessary behavior of the component. The testing design of components is the easiest of these tasks. If the component has been correctly designed, the interfaces need to be clear and well-defined and the behaviour should be well-capsulated.
While components may have altered the balance of knowledge needed to developers but they haven't significantly streamlined the task, or drastically altered the fundamental requirements for training and skills. The abilities of developers and designers are similar to the skills required for large-scale objects-oriented design and development. Good components and objects have several design features like well-designed designs, seamless interfaces flexibility, and completeness. In the same way, creating these systems requires expertise in readability, performance and the ability to extend. Mira Mezini and Klaus Ostermann (2002).
Making quality components requires more knowledge and understanding of the requirements of the domain in which it is used. It could be that global understanding of systems becomes less important in the component world. But, the problems that emergent behavior raise the need for an understanding of global components' interactions as well as local knowledge of each components' behaviour. White Paper, Microsoft Corporation, 2001.
A software or system requirement which defines the function an entire system's software or component of the system software must be able to perform. These are requirements in software which define the system's behavior, that is, the basic procedure or process that the hardware and software components of the system use to generate outputs. Contrast this with nonfunctional requirements for performance Software or system requirements that define a specific performance feature that a software system or component should have, for instance the speed of operation, its accuracy or frequency, requirements for external interfaces: White Paper, Microsoft Corporation 2001.
A software or system requirement that defines a hardware, program, or data component to which a system component is required to communicate, or specifies limitations regarding formats, time or other aspects triggered by the interface design restriction (requirements) A software requirements that influence or constrains the design of an software system or component of a system.
Some examples of constraints in design include physical requirements as well as performance requirements, software development standards and software quality assurance (SQA) standard quality attributes (requirement) Requirement that defines the extent of an attribute which affects the quality of the software or system should have, for instance reliability, maintainability or usability. White Paper, Microsoft Corporation, 2001.
In the field of system software engineering A document that outlines the roles software is required to be able to perform, the degree of performance (speed as well as accuracy and the like) as well as the requirements for interfaces between the software as well as its surroundings, the nature and extent of the constraints to design, as well as the quality of final products not functional requirement; a software requirement that specifies not the things the software is going to accomplish, but rather, how the software does it. For example software performance requirements and requirements for software's external interface as well as design constraints in software and attributes of software quality. Mira Mezini and Klaus Ostermann (2002).
Engineers have long known that the less a component of a system is aware about other components of the system the better the system as a whole. Systems with components that are completely independent of one another are much easier to fix and improve than those where they have strong interdependencies between certain or all components. Highly independent components of a system can be created in the event that there is a minimal degree of interaction between the components and every component is co-operative. Coupling is an indicator of the strength of connection between two systems components. White Paper, Microsoft Corporation, 2001.
The more that a particular component knows about the other the more tight (worse) the relationship between the two components. Cohesion is the measure of how logically linked the components of a component are to one another as well as to the overall component. The more logically connected the components are to one another, the greater (better) the degree of cohesion for the component. The components that comprise an object-oriented system display the phenomenon of object coupling as well as cohesion.
Object coupling is the measure of interrelations between the objects that comprise the system. The more a particular object is aware of another object in the system the more tight (worse) the relationship between the two objects. In order to build systems using objects, we have to join (to at least a certain extent) the components of the system. Mira Mezini and Klaus Ostermann (2002).
Object-oriented technology is both massive and sweeping. The end users of computer systems and computer-based devices can see the impact of this technology as it manifests itself in increasingly simple-to-use software programs and operating systems as well as more flexible services offered by various industries, such like telecommunications, banking, as well as cable TV. For software engineers, objects-oriented technology includes objects-oriented programming languages, object-oriented methods of development, managing objects-oriented projects and computer hardware and computer-aided object-oriented software engineering, among other things. It's not unusual that there's some confusion over the meaning of object-oriented terms and concepts. Khaled Khan and Jun Han (2002).
A lot of the terms employed in the field of object-oriented technology were initially used to refer to objects-oriented programming (coding) concepts. Specifically, although the terms were borrowed from a non-computer-software perspective, they were first used extensively to describe concepts embodied in object-oriented programming languages, such as Smalltalk, C++, and Eiffel. But, they are extremely beneficial even though one does not plans to write software in the first place.
For instance an industrial modeler might build an object-oriented model of a facility that manufactures plastics. Molding equipment, plastic parts as well as those "recipes" (proportional mixtures) that comprise the chemical mixtures used in the production of the various plastics can all be described using object-oriented terms. Additionally, static and dynamic connections between these items can also be described using objects-oriented terms. Keep in mind that there's no definitive set of definitions for objects-oriented terms and concepts. Depending on who you're speaking to, the terms and definitions may differ little. Khaled Khan and Jun Han (2002).
Copyright © 2023 Tuan Scitech - All Rights Reserved.
Powered by GoDaddy
We use cookies to analyze website traffic and optimize your website experience. By accepting our use of cookies, your data will be aggregated with all other user data.