Misplaced Pages

#443556

79-624: Because all components of the MEAN stack support programs that are written in JavaScript, MEAN applications can be written in one language for both server-side and client-side execution environments. Though often compared directly to other popular web development stacks such as the LAMP stack , the components of the MEAN stack are higher-level including a web application presentation layer and not including an operating system layer. The acronym MEAN

158-401: A computer network . Typically, a client is a computer application , such as a web browser , that runs on a user 's local computer , smartphone , or other device, and connects to a server as necessary. Operations may be performed client-side because they require access to information or functionality that is available on the client but not on the server, because the user needs to observe

237-417: A computer security context, server-side vulnerabilities or attacks refer to those that occur on a server computer system, rather than on the client side, or in between the two . For example, an attacker might exploit an SQL injection vulnerability in a web application in order to maliciously change or gain unauthorized access to data in the server's database . Alternatively, an attacker might break into

316-464: A foreign function interface for making calls to the lower-level language. Different programming languages provide different types of abstraction, depending on the intended applications for the language. For example: Analysts have developed various methods to formally specify software systems. Some known methods include: Specification languages generally rely on abstractions of one kind or another, since specifications are typically defined earlier in

395-508: A model of computation that is interchangeable with others. The software is structured in architectures to enable humans to create the enormous systems by concentrating on a few issues at a time. These architectures are made of specific choices of abstractions. Greenspun's tenth rule is an aphorism on how such an architecture is both inevitable and complex. Language abstraction is a central form of abstraction in computing: new artificial languages are developed to express specific aspects of

474-775: A user 's local computer , smartphone , or other device. Operations may be performed server-side because they require access to information or functionality that is not available on the client , or because performing such operations on the client side would be slow, unreliable, or insecure . Client and server programs may be commonly available ones such as free or commercial web servers and web browsers , communicating with each other using standardized protocols . Or, programmers may write their own server, client, and communications protocol which can only be used with one another. Server-side operations include both those that are carried out in response to client requests, and non-client-oriented operations such as maintenance tasks. In

553-412: A web server serves web pages and a file server serves computer files . A shared resource may be any of the server computer's software and electronic components, from programs and data to processors and storage devices . The sharing of resources of a server constitutes a service . Whether a computer is a client, a server, or both, is determined by the nature of the application that requires

632-501: A client-server or client-queue-client network, peers communicate with each other directly. In peer-to-peer networking, an algorithm in the peer-to-peer communications protocol balances load , and even peers with modest resources can help to share the load. If a node becomes unavailable, its shared resources remain available as long as other peers offer it. Ideally, a peer does not need to achieve high availability because other, redundant peers make up for any resource downtime ; as

711-440: A client-side attack would normally be an attacker's only opportunity to gain access to the decrypted contents. For instance, the attacker might cause malware to be installed on the client system, allowing the attacker to view the user's screen, record the user's keystrokes, and steal copies of the user's encryption keys, etc. Alternatively, an attacker might employ cross-site scripting vulnerabilities to execute malicious code on

790-437: A consequence, automatic methods for deriving information on the behavior of computer programs either have to drop termination (on some occasions, they may fail, crash or never yield out a result), soundness (they may provide false information), or precision (they may answer "I don't know" to some questions). Abstraction is the core concept of abstract interpretation . Model checking generally takes place on abstract versions of

869-476: A data set (a server-side operation) and sends it back to the client. The client then analyzes the data (a client-side operation), and, when the analysis is complete, displays it to the user (as with Google Earth) and/or transmits the results of calculations back to the server (as with SETI@home). In the context of the World Wide Web , commonly encountered computer languages which are evaluated or run on

SECTION 10

#1732802034444

948-478: A database, use the logical level of abstraction. View level: The highest level of abstraction describes only part of the entire database. Even though the logical level uses simpler structures, complexity remains because of the variety of information stored in a large database. Many users of a database system do not need all this information; instead, they need to access only a part of the database. The view level of abstraction exists to simplify their interaction with

1027-419: A less detailed, but safe, definition of the observed program behaviors. For instance, one may observe only the final result of program executions instead of considering all the intermediate steps of executions. Abstraction is defined to a concrete (more precise) model of execution. Abstraction may be exact or faithful with respect to a property if one can answer a question about the property equally well on

1106-431: A lookup table may be implemented in various ways: as a hash table , a binary search tree , or even a simple linear list of (key:value) pairs. As far as client code is concerned, the abstract properties of the type are the same in each case. Of course, this all relies on getting the details of the interface right in the first place, since any changes there can have major impacts on client code. As one way to look at this:

1185-417: A number of client programs (e.g. most modern web browsers can request and receive data using both HTTP and FTP). In the case of more specialized applications, programmers may write their own server, client, and communications protocol which can only be used with one another. Programs that run on a user's local computer without ever sending or receiving data over a network are not considered clients, and so

1264-550: A programming language can influence its overall usability . The Cognitive dimensions framework includes the concept of abstraction gradient in a formalism. This framework allows the designer of a programming language to study the trade-offs between abstraction and other characteristics of the design, and how changes in abstraction influence the language usability. Abstractions can prove useful when dealing with computer programs, because non-trivial properties of computer programs are essentially undecidable (see Rice's theorem ). As

1343-440: A programming language, some features let the programmer create new abstractions. These include subroutines , modules , polymorphism , and software components . Some other abstractions such as software design patterns and architectural styles remain invisible to a translator and operate only in the design of a system. Some abstractions try to limit the range of concepts a programmer needs to be aware of, by completely hiding

1422-411: A project, (and at a more abstract level) than an eventual implementation. The UML specification language, for example, allows the definition of abstract classes, which in a waterfall project, remain abstract during the architecture and specification phase of the project. Programming languages offer control abstraction as one of the main purposes of their use. Computer machines understand operations at

1501-410: A relatively concrete, "lower" level, which tends to provide an increasingly "granular" representation. For example, gates build on electronic circuits, binary on gates, machine language on binary, programming language on machine language, applications and operating systems on programming languages. Each level is embodied, but not determined, by the level beneath it, making it a language of description that

1580-438: A request, and the server returns a response. This exchange of messages is an example of inter-process communication . To communicate, the computers must have a common language, and they must follow rules so that both the client and the server know what to expect. The language and rules of communication are defined in a communications protocol . All protocols operate in the application layer . The application layer protocol defines

1659-467: A sample Java fragment to represent some common farm "animals" to a level of abstraction suitable to model simple aspects of their hunger and feeding. It defines an Animal class to represent both the state of the animal and its functions: With the above definition, one could create objects of type Animal and call their methods like this: In the above example, the class Animal is an abstraction used in place of an actual animal, LivingThing

SECTION 20

#1732802034444

1738-403: A server farm. Each load balancer sits between client devices and backend servers, receiving and then distributing incoming requests to any available server capable of fulfilling them. In a peer-to-peer network, two or more computers ( peers ) pool their resources and communicate in a decentralized system . Peers are coequal, or equipotent nodes in a non-hierarchical network. Unlike clients in

1817-447: A server is used so that the initial data can be prefetched before it is loaded in the user's browser. Node.js is the application runtime that the MEAN stack runs on. The use of Node.js, which is said to represent a "JavaScript Everywhere" paradigm, is integral to the MEAN stack which relies on that concept. Server-side The client–server model is a distributed application structure that partitions tasks or workloads between

1896-506: A server system using vulnerabilities in the underlying operating system and then be able to access database and other files in the same manner as authorized administrators of the server. In the case of distributed computing projects such as SETI@home and the Great Internet Mersenne Prime Search , while the bulk of the operations occur on the client side, the servers are responsible for coordinating

1975-417: A server. Clients, therefore, initiate communication sessions with servers, which await incoming requests. Examples of computer applications that use the client–server model are email , network printing, and the World Wide Web . The server component provides a function or service to one or many clients, which initiate requests for such services. Servers are classified by the services they provide. For example,

2054-453: A service is an abstraction of computer resources and a client does not have to be concerned with how the server performs while fulfilling the request and delivering the response. The client only has to understand the response based on the relevant application protocol , i.e. the content and the formatting of the data for the requested service. Clients and servers exchange messages in a request–response messaging pattern . The client sends

2133-527: A shared functional heritage from Lisp . C++ exemplifies another extreme: it relies heavily on templates and overloading and other static bindings at compile-time, which in turn has certain flexibility problems. Although these examples offer alternate strategies for achieving the same abstraction, they do not fundamentally alter the need to support abstract nouns in code – all programming relies on an ability to abstract verbs as functions, nouns as data structures, and either as processes. Consider for example

2212-489: A short period. A computer can only perform a limited number of tasks at any moment, and relies on a scheduling system to prioritize incoming requests from clients to accommodate them. To prevent abuse and maximize availability , the server software may limit the availability to clients. Denial of service attacks are designed to exploit a server's obligation to process requests by overloading it with excessive request rates. Encryption should be applied if sensitive information

2291-498: A system which handles payroll on ships and at shore offices: These layers produce the effect of isolating the implementation details of one component and its assorted internal methods from the others. Object-oriented programming embraces and extends this concept. Data abstraction enforces a clear separation between the abstract properties of a data type and the concrete details of its implementation. The abstract properties are those that are visible to client code that makes use of

2370-479: A system. Modeling languages help in planning. Computer languages can be processed with a computer. An example of this abstraction process is the generational development of programming language from the machine language to the assembly language and the high-level language . Each stage can be used as a stepping stone for the next stage. The language abstraction continues for example in scripting languages and domain-specific programming languages . Within

2449-457: A variable's label and the resultant location in physical or virtual memory, storing the binary representation of "15" to that memory location, etc. Without control abstraction, a programmer would need to specify all the register/binary-level steps each time they simply wanted to add or multiply a couple of numbers and assign the result to a variable. Such duplication of effort has two serious negative consequences: Structured programming involves

MEAN (solution stack) - Misplaced Pages Continue

2528-431: Is a fundamental concept in computer science and software engineering , especially within the object-oriented programming paradigm. Examples of this include: The essence of abstraction is preserving information that is relevant in a given context, and forgetting information that is irrelevant in that context. – John V. Guttag Computing mostly operates independently of the concrete world. The hardware implements

2607-442: Is a further abstraction (in this case a generalisation) of Animal . If one requires a more differentiated hierarchy of animals – to differentiate, say, those who provide milk from those who provide nothing except meat at the end of their lives – that is an intermediary level of abstraction, probably DairyAnimal (cows, goats) who would eat foods suitable to giving good milk, and MeatAnimal (pigs, steers) who would eat foods to give

2686-414: Is any computer connected to a network. Whereas the words server and client may refer either to a computer or to a computer program, server-host and client-host always refer to computers. The host is a versatile, multifunction computer; clients and servers are just programs that run on a host. In the client–server model, a server is more likely to be devoted to the task of serving. An early use of

2765-438: Is called polymorphism . When it proceeds in the opposite direction, inside the types or classes, structuring them to simplify a complex set of relationships, it is called delegation or inheritance . Various object-oriented programming languages offer similar facilities for abstraction, all to support a general strategy of polymorphism in object-oriented programming, which includes the substitution of one type for another in

2844-436: Is possible with any of the others. A great many operation overloads, data type by data type, can have the same effect at compile-time as any degree of inheritance or other means to achieve polymorphism. The class notation is simply a coder's convenience. Decisions regarding what to abstract and what to keep under the control of the coder become the major concern of object-oriented design and domain analysis —actually determining

2923-446: Is somewhat self-contained. Since many users of database systems lack in-depth familiarity with computer data-structures, database developers often hide complexity through the following levels: Physical level: The lowest level of abstraction describes how a system actually stores data. The physical level describes complex low-level data structures in detail. Logical level: The next higher level of abstraction describes what data

3002-403: Is to be communicated between the client and the server. When a bank customer accesses online banking services with a web browser (the client), the client initiates a request to the bank's web server. The customer's login credentials may be stored in a database , and the webserver accesses the database server as a client. An application server interprets the returned data by applying

3081-428: Is very commonly filled by MongoDB because its use of JSON-like documents for interacting with data as opposed to the row/column model allows it to integrate well with the other (JavaScript-based) components of the stack. Express.js (also referred to as Express) is a modular web application framework package for Node.js . While Express is capable of acting as an internet-facing web server, even supporting SSL/TLS out of

3160-451: The 2000s, web applications matured enough to rival application software developed for a specific microarchitecture . This maturation, more affordable mass storage , and the advent of service-oriented architecture were among the factors that gave rise to the cloud computing trend of the 2010s. In addition to the client-server model, distributed computing applications often use the peer-to-peer (P2P) application architecture. In

3239-479: The abstraction may simply yield a result of undecidability . For instance, students in a class may be abstracted by their minimal and maximal ages; if one asks whether a certain person belongs to that class, one may simply compare that person's age with the minimal and maximal ages; if his age lies outside the range, one may safely answer that the person does not belong to the class; if it does not, one may only answer "I don't know". The level of abstraction included in

MEAN (solution stack) - Misplaced Pages Continue

3318-403: The abstractions they are built on. The software engineer and writer Joel Spolsky has criticized these efforts by claiming that all abstractions are leaky – that they can never completely hide the details below; however, this does not negate the usefulness of abstraction. Some abstractions are designed to inter-operate with other abstractions – for example, a programming language may contain

3397-491: The availability and load capacity of peers change, the protocol reroutes requests. Both client-server and master-slave are regarded as sub-categories of distributed peer-to-peer systems. Abstraction (computer science) In software engineering and computer science , abstraction is the process of generalizing concrete details, such as attributes , away from the study of objects and systems to focus attention on details of greater importance. Abstraction

3476-402: The bank's business logic and provides the output to the webserver. Finally, the webserver returns the result to the client web browser for display. In each step of this sequence of client–server message exchanges, a computer processes a request and returns data. This is the request-response messaging pattern. When all the requests are met, the sequence is complete and the web browser presents

3555-430: The basic patterns of the dialogue. To formalize the data exchange even further, the server may implement an application programming interface (API). The API is an abstraction layer for accessing a service. By restricting communication to a specific content format , it facilitates parsing . By abstracting access, it facilitates cross-platform data exchange. A server may receive requests from many distinct clients in

3634-445: The best meat-quality. Such an abstraction could remove the need for the application coder to specify the type of food, so they could concentrate instead on the feeding schedule. The two classes could be related using inheritance or stand alone, and the programmer could define varying degrees of polymorphism between the two types. These facilities tend to vary drastically between languages, but in general each can achieve anything that

3713-435: The box, it is often used in conjunction with a reverse proxy such as NGINX or Apache for performance reasons. Typically data is fetched using Ajax techniques and rendered in the browser on the client-side by a client-side application framework, however as the stack is commonly entirely JavaScript-based, in some implementations of the stack, server-side rendering where the rendering of the initial page can be offloaded to

3792-543: The client side include: An early form of client–server architecture is remote job entry , dating at least to OS/360 (announced 1964), where the request was to run a job , and the response was the output. While formulating the client–server model in the 1960s and 1970s, computer scientists building ARPANET (at the Stanford Research Institute ) used the terms server-host (or serving host ) and user-host (or using-host ), and these appear in

3871-577: The client's system without needing to install any permanently resident malware. Distributed computing projects such as SETI@home and the Great Internet Mersenne Prime Search, as well as Internet-dependent applications like Google Earth , rely primarily on client-side operations. They initiate a connection with the server (either in response to a user query, as with Google Earth, or in an automated fashion, as with SETI@home), and request some data. The server selects

3950-411: The client, etc. In the context of the World Wide Web , commonly encountered server-side computer languages include: However, web applications and services can be implemented in almost any language, as long as they can return data to standards-based web browsers (possibly via intermediary programs) in formats which they can use. Client-side refers to operations that are performed by the client in

4029-483: The client-server model, the server is often designed to operate as a centralized system that serves many clients. The computing power, memory and storage requirements of a server must be scaled appropriately to the expected workload. Load-balancing and failover systems are often employed to scale the server beyond a single physical machine. Load balancing is defined as the methodical and efficient distribution of network or application traffic across multiple servers in

SECTION 50

#1732802034444

4108-402: The clients, sending them data to analyze, receiving and storing results, providing reporting functionality to project administrators, etc. In the case of an Internet-dependent user application like Google Earth , while querying and display of map data takes place on the client side, the server is responsible for permanent storage of map data, resolving user queries into map data to be returned to

4187-452: The concrete or abstract model. For instance, if one wishes to know what the result of the evaluation of a mathematical expression involving only integers +, -, ×, is worth modulo n , then one needs only perform all operations modulo n (a familiar form of this abstraction is casting out nines ). Abstractions, however, though not necessarily exact , should be sound . That is, it should be possible to get sound answers from them—even though

4266-448: The data to the customer. This example illustrates a design pattern applicable to the client–server model: separation of concerns . Server-side refers to programs and operations that run on the server . This is in contrast to client-side programs and operations which run on the client . (See below) "Server-side software" refers to a computer application , such as a web server , that runs on remote server hardware , reachable from

4345-541: The data type—the interface to the data type—while the concrete implementation is kept entirely private, and indeed can change, for example to incorporate efficiency improvements over time. The idea is that such changes are not supposed to have any impact on client code, since they involve no difference in the abstract behaviour. For example, one could define an abstract data type called lookup table which uniquely associates keys with values , and in which values may be retrieved by specifying their corresponding keys. Such

4424-496: The database stores, and what relationships exist among those data. The logical level thus describes an entire database in terms of a small number of relatively simple structures. Although implementation of the simple structures at the logical level may involve complex physical level structures, the user of the logical level does not need to be aware of this complexity. This is referred to as physical data independence . Database administrators , who must decide what information to keep in

4503-411: The detailed analysis but the domain and legacy analysis would be unchanged—thus it is entirely under the control of the programmer, and it is called an abstraction in object-oriented programming as distinct from abstraction in domain or legacy analysis. When discussing formal semantics of programming languages , formal methods or abstract interpretation , abstraction refers to the act of considering

4582-441: The domain is the barnyard, the live pigs and cows and their eating habits are the legacy constraints, the detailed analysis is that coders must have the flexibility to feed the animals what is available and thus there is no reason to code the type of food into the class itself, and the design is a single simple Animal class of which pigs and cows are instances with the same functions. A decision to differentiate DairyAnimal would change

4661-460: The early documents RFC 5 and RFC 4. This usage was continued at Xerox PARC in the mid-1970s. One context in which researchers used these terms was in the design of a computer network programming language called Decode-Encode Language (DEL). The purpose of this language was to accept commands from one computer (the user-host), which would return status reports to the user as it encoded the commands in network packets. Another DEL-capable computer,

4740-405: The interface forms a contract on agreed behaviour between the data type and client code; anything not spelled out in the contract is subject to change without notice. While much of data abstraction occurs through computer science and automation, there are times when this process is done manually and without programming intervention. One way this can be understood is through data abstraction within

4819-421: The low-level steps necessary to carry out this evaluation, and return the value "15", and then assign that value to the variable "a", are actually quite subtle and complex. The values need to be converted to binary representation (often a much more complicated task than one would think) and the calculations decomposed (by the compiler or interpreter) into assembly instructions (again, which are much less intuitive to

SECTION 60

#1732802034444

4898-625: The network, and a computer terminal has no operating system at all; it is only an input/output interface to the server. In contrast, a rich client , such as a personal computer , has many resources and does not rely on a server for essential functions. As microcomputers decreased in price and increased in power from the 1980s to the late 1990s, many organizations transitioned computation from centralized servers, such as mainframes and minicomputers , to rich clients. This afforded greater, more individualized dominion over computer resources, but complicated information technology management . During

4977-426: The operations of such programs would not be termed client-side operations. In a computer security context, client-side vulnerabilities or attacks refer to those that occur on the client / user's computer system, rather than on the server side , or in between the two . As an example, if a server contained an encrypted file or message which could only be decrypted using a key housed on the user's computer system,

5056-502: The operations or provide input, or because the server lacks the processing power to perform the operations in a timely manner for all of the clients it serves. Additionally, if operations can be performed by the client, without sending data over the network, they may take less time, use less bandwidth , and incur a lesser security risk. When the server serves data in a commonly used manner, for example according to standard protocols such as HTTP or FTP , users may have their choice of

5135-508: The process of conducting a systematic review of the literature. In this methodology, data is abstracted by one or several abstractors when conducting a meta-analysis , with errors reduced through dual data abstraction followed by independent checking, known as adjudication . In object-oriented programming theory, abstraction involves the facility to define objects that represent abstract "actors" that can perform work, report on and change their state, and "communicate" with other objects in

5214-417: The programmer: operations such as shifting a binary register left, or adding the binary complement of the contents of one register to another, are simply not how humans think about the abstract arithmetical operations of addition or multiplication). Finally, assigning the resulting value of "15" to the variable labeled "a", so that "a" can be used later, involves additional 'behind-the-scenes' steps of looking up

5293-427: The providers of a resource or service, called servers , and service requesters, called clients . Often clients and servers communicate over a computer network on separate hardware, but both client and server may be on the same device. A server host runs one or more server programs, which share their resources with clients. A client usually does not share any of its resources, but it requests content or service from

5372-465: The relevant relationships in the real world is the concern of object-oriented analysis or legacy analysis . In general, to determine appropriate abstraction, one must make many small decisions about scope (domain analysis), determine what other systems one must cooperate with (legacy analysis), then perform a detailed object-oriented analysis which is expressed within project time and budget constraints as an object-oriented design. In our simple example,

5451-498: The same or similar role. Although not as generally supported, a configuration or image or package may predetermine a great many of these bindings at compile-time , link-time , or loadtime . This would leave only a minimum of such bindings to change at run-time . Common Lisp Object System or Self , for example, feature less of a class-instance distinction and more use of delegation for polymorphism . Individual objects and functions are abstracted more flexibly to better fit with

5530-539: The server-host, received the packets, decoded them, and returned formatted data to the user-host. A DEL program on the user-host received the results to present to the user. This is a client–server transaction. Development of DEL was just beginning in 1969, the year that the United States Department of Defense established ARPANET (predecessor of Internet ). Client-host and server-host have subtly different meanings than client and server . A host

5609-423: The service functions. For example, a single computer can run a web server and file server software at the same time to serve different data to clients making different kinds of requests. The client software can also communicate with server software within the same computer. Communication between servers, such as to synchronize data, is sometimes called inter-server or server-to-server communication. Generally,

5688-423: The shared resources of other hosts. Centralized computing , however, specifically allocates a large number of resources to a small number of computers. The more computation is offloaded from client-hosts to the central computers, the simpler the client-hosts can be. It relies heavily on network resources (servers and infrastructure) for computation and storage. A diskless node loads even its operating system from

5767-454: The splitting of complex program tasks into smaller pieces with clear flow-control and interfaces between components, with a reduction of the complexity potential for side-effects. In a simple program, this may aim to ensure that loops have single or obvious exit points and (where possible) to have single exit points from functions and procedures. In a larger system, it may involve breaking down complex tasks into many different modules. Consider

5846-416: The studied systems. Computer science commonly presents levels (or, less commonly, layers ) of abstraction, wherein each level represents a different model of the same information and processes, but with varying amounts of detail. Each level uses a system of expression involving a unique set of objects and compositions that apply only to a particular domain. Each relatively abstract, "higher" level builds on

5925-410: The system. The system may provide many views for the same database. The ability to provide a design of different levels of abstraction can Systems design and business process design can both use this. Some design processes specifically generate designs that contain various levels of abstraction. Layered architecture partitions the concerns of the application into stacked groups (layers). It

6004-417: The system. The term encapsulation refers to the hiding of state details, but extending the concept of data type from earlier programming languages to associate behavior most strongly with the data, and standardizing the way that different data types interact, is the beginning of abstraction . When abstraction proceeds into the operations defined, enabling objects of different types to be substituted, it

6083-407: The very low level such as moving some bits from one location of the memory to another location and producing the sum of two sequences of bits. Programming languages allow this to be done in the higher level. For example, consider this statement written in a Pascal -like fashion: To a human, this seems a fairly simple and obvious calculation ( "one plus two is three, times five is fifteen" ). However,

6162-597: The word client occurs in "Separating Data from Function in a Distributed File System", a 1978 paper by Xerox PARC computer scientists Howard Sturgis, James Mitchell, and Jay Israel. The authors are careful to define the term for readers, and explain that they use it to distinguish between the user and the user's network node (the client). By 1992, the word server had entered into general parlance. The client-server model does not dictate that server-hosts must have more resources than client-hosts. Rather, it enables any general-purpose computer to extend its capabilities by using

6241-463: Was coined by Valeri Karpov. He introduced the term in a 2013 blog post and the logo concept, initially created by Austin Anderson for the original MEAN stack LinkedIn group, is an assembly of the first letter of each component of the MEAN acronym. MongoDB is a NoSQL database program that uses JSON-like BSON (binary JSON) documents with optional schemas. The role of the database in the MEAN stack

#443556