Search 250 million research papers

Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.

About 62 papers for “Factory (object-oriented programming)”

FACTORY: AN OBJECT-ORIENTED PARALLEL PROGRAMMING SUBSTRATE FOR DEEP MULTIPROCESSORS

Dimitrios S. Nikolopoulos, Phil Kearns, Bruce Lowekamp · 2005

Cited by 0

Bridging Functional and Object-Oriented Programming

Yannis Smaragdakis, Brian McNamara · 2000

Proponents of the functional programming paradigm\ncontend that higher-order functions combined\nwith (parametric) polymorphism result in\nmuch more reusable code. Object-oriented (OO)\nprogramming has independently followed a parallel\napproach to reusability. Objects can be used\ninstead of higher-order functions and subtype polymorphism\npartially substitutes parametric polymorphism.\nIn this paper, we draw strong analogies between\nthe object-oriented and functional programming\nparadigms. We show that several common OO\ndesign patterns (Visitor, Virtual Proxy, Command,\nObserver, and more) are closely related to functional\nprogramming patterns. Additionally, we\nshow how better support for functional programming\nin OO languages can result in improvements\nfor many design patterns (Command, Virtual\nProxy, Builder, Abstract Factory, and more).\nThe context for demonstrating our ideas is the\nFC++ library. FC++ adds to C++ many of the capabilities\nof modern functional programming languages,\nwithout any modiÞcation to the base\nlanguage. Compared to other attempts to program\nfunctionally in C++, FC++ offers much richer support\nfor polymorphic functions (allowing functions\nthat take polymorphic functions as arguments and/\nor return them as results).

Cited by 7

D.S.: Factory: An Object-Oriented Parallel Programming Substrate for Deep Multiprocessors

Scott Schneider, Christos D. Antonopoulos, Dimitrios S. Nikolopoulos · 2005

Abstract. Recent advances in processor technology such as Simultaneous Multithreading (SMT) and Chip Multiprocessing (CMP) enable parallel processing on a single die. These processors are used as building blocks of shared-memory multiprocessor systems, or clusters of multiprocessors. New programming languages and tools are necessary due to the complexities introduced by systems with multigrain, multilevel execution capabilities. This paper introduces Factory, an object-oriented parallel programming substrate which allows programmers to express multigrain parallelism, but alleviates them from having to manage it. Factory is written in C++ without introducing any extensions to the language. Because it leverages existing C++ constructs to express arbitrarily nested parallel computations, it is highly portable and does not require extra compiler support. Moreover, Factory offers programmability and performance comparable to already established multithreading substrates. Keywords: Multithreading substrate, Object-oriented parallel programming, Deep parallel architectures, Multiparadigm parallelism, Portability,

Cited by 0

Extreme programming evaluation framework for object-oriented languages -- version 1.1

Laurie Williams, William Krebs, Lucas Layman · NCSU Libraries Repository (North Carolina State University Libraries) · 2003

The Extreme Programming development Methodology (XP) seems appropriate for some teams or projects. Anecdotal stories from developers who have tried XP are often favorable. However, there is little empirical evidence to support or refute claims regarding XP. The Extreme Programming Evaluation Framework (XP-EF) provides a benchmark measurement framework for researchers and practitioners to assess concretely the extent to which an organization has adopted XP practices and the result of this adoption. Through replication of case studies which utilize the structure of the XP-EF, the community can build an experience factory of empirical findings on XP; the results of these case studies can be integrated and combined. 1.

Cited by 10Open access

Object Oriented Programming in Python for Scalable AI Application Development

Shaik Mabasha, Tupili Sangeetha, P. Shanmukh Sagar Kumar · 2026

The rapid evolution of artificial intelligence (AI) technologies has intensified the demand for scalable, maintainable, and modular software architectures. Object-oriented programming (OOP), with its core principles of encapsulation, inheritance, and polymorphism, provides a robust foundation for structuring AI systems that can adapt to increasing complexity and changing requirements. This chapter explores the integration of OOP constructs within the Python programming language to design efficient AI applications that support long-term maintainability and seamless scalability. By leveraging class-based abstractions, design patterns, and modular workflow components, AI pipelines can be structured for enhanced reusability, testability, and collaboration. The chapter provides a comprehensive analysis of OOP methodologies applied across core AI development phases, including data preprocessing, model design, hyperparameter configuration, logging, and deployment. Emphasis is placed on aligning Python’s object-oriented capabilities with popular machine learning frameworks such as TensorFlow, PyTorch, XGBoost, LightGBM, and CatBoost. Advanced design patterns such as factory, strategy, and MVC are demonstrated to enhance component separation and architectural clarity. The insights presented serve as a practical and theoretical guide for researchers, developers, and engineers seeking to build sustainable AI systems that meet enterprise-grade performance, interpretability, and maintainability standards.

Cited by 0Open access

Teaching Object-Oriented Software Architecture by Example: The Games Factory

Hermann Hüni, Jucker Informatik, Igor Metz · 1992

This paper describes the outline of our lecture and the experience we have had when introducing object--oriented programming, design, and software architecture to students of different educational and vocational backgrounds. While other courses on object--oriented programming only show how to implement things in an object--oriented way, we emphasize on the production of reusable class libraries and frameworks. 1.1 The audience

Cited by 0

An Overview of Object-Oriented Programming (Oop) And Its Impact on Software Design

Sagar Vishnubhai Sheta · 2024

This research aims to identify and compare the fundamental concepts of OOP and analyze the effects on the software structure especially for its scalability, modularity, and maintainability. The presented study, considered users' OOP notions encompassing encapsulation, inheritance, polymorphism, and abstraction and discusses their role in the development of flexible, reusable, and extensible software systems. Further, the commonly used design patterns, including Singleton, Factory, and Observer, are discussed to investigate their contribution to the improvement of system maintainability for the long term. The research also seeks to establish how OOP will interact with other programming paradigms for purposes of understanding what impacts the general software system performance. This paper has shown, by example, the applicability and value of OOP principles and patterns towards enhancing software designs, and its flexibility for change as requirements shift.

Cited by 0Open access

A framework based on design patterns for providing persistence in object-oriented programming languages

Jörg Kienzle, et al. · 2000

This paper describes an approach to providing object persistence in object-oriented programming languages without modifying the run-time system or the language itself. By successively applying design patterns such as the Serializer, Factory Method, and Strategy patterns we develop an object-oriented framework for providing object persistence. The advantages of object-orientation are highlighted: structured classification through class-hier-archies, extensibility and promotion of reuse. The framework clearly separates persistence control from storage control. A hierarchy of different storage types, useful in different application domains, is introduced. The framework does not rely on any kind of special program-ming language features. It only uses basic object-oriented programming techniques, and is therefore implementable in any object-oriented programming language. An experimental

Cited by 0

Impact of innovations in object-oriented programming on the creation of new design patterns

Jose Belisario Vera Vera, Julio Agustin Molina Zambrano, Yimmy Salvador Loor Vera et al. · Minerva · 2023

This research focuses on delving into the impact of innovations in object-oriented programming on creating new design patterns. This paper presents possible innovations in object-oriented programming and its impact on design patterns for software development. The developers of these systems face the challenge of designing not a single system but several ways to solve the same problem and introduce innovations that allow them to modify and extend the codes quickly and easily. To illustrate how a design pattern is applied in an object-oriented system, an order management system for an online vehicle parts sale is shown. For this case, the Factory Method design pattern is selected to handle creating product objects (spare parts) dynamically and efficiently, which is a first step in building large systems.

Cited by 0Open access

Impact of innovations in object-oriented programming on the creation of new design patterns

Vera Vera, José Belisario, Molina Zambrano, Julio Agustin, Loor Vera, Yimmy Salvador et al. · Dialnet (Universidad de la Rioja) · 2023

Cited by 0Open access

A Framework Based on Design Patterns for Providing Persistence In Object-Oriented Programming Languages

Jörg Kienzle, Alexander Romanovsky, Newcastle upon Tyne Univ. (United Kingdom). Computing Science · OpenGrey (Institut de l'Information Scientifique et Technique) · 2000

. This paper describes an approach to providing object persistence in object-oriented programming languages without modifying the run-time system or the language itself. By successively applying design patterns such as the Serializer, Factory Method, and Strategy patterns we develop an object-oriented framework for providing object persistence. The advantages of object-orientation are highlighted: structured classification through class-hierarchies, extensibility and promotion of reuse. The framework clearly separates persistence control from storage control. A hierarchy of different storage types, useful in different application domains, is introduced. The framework does not rely on any kind of special programming language features. It only uses basic object-oriented programming techniques, and is therefore implementable in any object-oriented programming language. An experimental implementation in Ada 95 is presented. Keywords. Persistence, Stable Storage, Object-Oriented Framework, Design Patterns. 1

Cited by 2Open access

Teaching OO Software Engineering by Example: The Games Factory

Hermann Hu auni, Igor Metz · Computer Science Education · 1993

Object‐oriented analysis, design, and programming is a software development technology which has attracted universal attention in the past few years. We do not think that object‐oriented technology is a completely new approach to software construction; it is merely the consequent continuation of software engineering principles which have evolved since 1968, the year of the birth of software engineering. This article describes a course on software engineering with objects which track the evolution of this discipline. We work through the history of these concepts using a single application domain, demonstrating how the relevant analysis and design methods evolved over time, culminating in object‐oriented techniques.

Cited by 2

Energy conscious factory method design pattern for mobile devices with C# and intermediate language

Kayun Chantarasathaporn, Chonawat Srisa-an · 2006

Design Patterns have gained more and more acceptances since their emerging in software development world last decade and become another de facto standard of essential knowledge for Object-Oriented Programming developers nowadays.

Cited by 5

Open architecture-based factory automation systems

Likun Wang · IEEE Aerospace and Electronic Systems Magazine · 2004

This mainly discusses the next generation factory automation systems, i.e., open systems. Along the dimension of open architecture, it discusses some standardized methodologies involving Linux open source operating systems, platform independent programming languages, systematic object-oriented software engineering, web-based information publishing, virtual instrument-based system structure, distributed and embedded real-time systems, etc., and their applications in factory automation systems. The resulting open systems are capable of keeping up with the evolving requirements in the factory automation arena, and it is expected that the strict use of standards would bring benefits to enterprises in the long sight.

Cited by 4

Scheduling orkforce and Workflow in a Hig Volumne Factory

Oded Berman, Richard C. Larson, Edieal J. Pinker · 1997

W 7e define a high volume factory to be a connected network of workstations, at which assigned workers process work-in-progress that flows at high rates through the workstations. A high rate usually implies that each worker processes many pieces per hour, enough so that work can be described as a deterministic hourly flow rate rather than, say, a stochastic number of discrete entities. Examples include mail processing and sorting, check processing, telephoned order processing, and inspecting and packaging of certain foods. Exogenous work may enter the factory at any workstation according to any time-of-day profile. Work-in-progress flows through the factory in discrete time according to Markovian routings. Workers, who in general are cross-trained, may work part time or full time shifts, may start work only at designated shift starting times, and may change job assignments at mid shift. In order to smooth the flow of work-in-progress through the service factory, work-in-progress may be temporarily inventoried (in buffers) at work stations. The objective is to schedule the workers (and correspondingly, the workflow) in a manner that minimizes labor costs subject to a variety of service-level, contractual and physical constraints. Motivated in part by analysis techniques of discrete time linear time-invariant (LTI) systems, an object-oriented linear programming (OOLP) model is developed. Using exogenous input work profiles typical of large U.S. mail processing facilities, illustrative computational results are included. (Linear Programming; Scheduling; Manufacturing; Object-oriented; Queueing; Queueing Networks; Markov Chains)

Cited by 0

Object-Oriented Approach to Factory Computer Network Automation

Debra Loefer Sattler · e-Publications@Marquette (Marquette University) · 1990

Factory automation has been hindered by devices with a wide variety of physical connections and protocols that are incompatible. One of the consequences of this incompatibility in factory devices is the constant need for custom software. This is most apparent at the factory cell level for devices that are connected by serial or multi-drop links. In this thesis these links are referred to as field bus networks. The computer acting as a gateway and providing control functions for the devices on these networks is referred to as a field bus node. Object-Oriented Design and Programming (OOD or OOP) has proved to be a better way to handle complexity in many other areas. The proven benefits of OOP compared with procedural programming in general are that it is more reusable, maintainable and extendible. This thesis focuses on an object-oriented approach to the design and integration of the lowest level of a factory automation network: factory cell, field bus type networks. This is the first time for the application of OOD and OOP to computer networks in general. This is a new approach to the design of field bus node and network software. Currently, many authors in the factory automation area are mentioning the advantages of an objected-oriented approach to problems in this area This is the first time OOD and OOP have been applied to factory automation computer networks. The work in this thesis suggests an object-oriented design for gateways or factory nodes that connect field bus type networks with the rest of the factory. Another point of significance of this thesis for factory networks is that it is independent of any factory standard for communications. This is especially important because, despite MAP, there is no clear consensus as to what the standard should be. This approach also provides a way to incorporate older devices that still have a useful life and therefore has potential economic advantages. This thesis includes background information about networks and factory automation in Chapter 2. Background information about OOP and OOD is presented in Chapter 3. Chapter 4 presents the conceptual framework of an OOD for field bus networks. Each of these chapters has a summary of key ideas developed as its last section. The essence of the conceptual model is presented in Tables 2-4 and the last section of Chapter 4. Chapter 5 is an evaluation of the model from the perspective of user interface requirements. Appendix A is a case study describing an actual system developed using a variation of the conceptual model.

Cited by 0

Applying Design Patterns

2024

This chapter gives the reader just a taste of how patterns can help them organize object-oriented concepts into high-level designs. The strategy design pattern is one way to support the dependency inversion principle. A factory in real life constructs tangible objects, such as tables or cars. There are two major types of factory-related patterns in object-oriented programming: the abstract factory pattern and the factory method pattern. It discusses the abstract factory pattern. The adapter provides the abstraction that the rest of the code uses and serves as the link between the desired abstraction and the actual underlying code. The proxy pattern is one of several patterns that divorce the abstraction of a class from its underlying representation. The iterator pattern provides a mechanism for separating algorithms or operations from the structure of the data on which they operate.

Cited by 0Open access

International Journal of Parallel Programming ( © 2007) DOI: 10.1007/s10766-007-0044-3 AsynchronousTyped Object Groups for Grid Programming

Laurent Baduel, Françoise Baude, Denis Caromel · 2006

This article presents an object-oriented mechanism to achieve group communication in large scale grids. Group communication is a crucial feature for high-performance and grid computing. While previous work on collective communications imposed the use of dedicated interfaces, we propose a scheme where one can initiate group communications using the standard public methods of the class by instantiating objects through a special object factory. The object factory utilizes casting and introspection to construct a “parallel processing enhanced ” implementation of the object which matches the original class ’ interface. This mechanism is then extended in an evolution of the classical SPMD programming paradigm into the domain of clusters and grids named “Object-Oriented SPMD”. OOSPMD provides interprocess (inter-object) communications via transparent remote method invocations rather than custom interfaces. Such typed group communication constitutes a basis for improvement of component models allowing advanced composition of parallel building blocks. The typed group pattern leads to an interesting, uniform, and complete model for programming applications intended to be run on clusters and grids.

Cited by 0

Pedagogies and Tools for Assimilating Object-Oriented Concepts Abstract OOP as an Enrichment of FP

Robert &quot;corky Cartwright, Dung &quot;zung Nguyen · 2011

At Rice University, we have a long history of teaching functional programming (FP) in Scheme in our first semester programming course. Five years ago, when we converted our second semester course from object-based programming (OBP) in C++ to object-oriented programming (OOP) in Java, we discovered that object-oriented program design and functional programming design are intimately connected. In both FP and OOP, the fundamental principle of program design is: the structure of a program should mirror the form of data that it processes. Moreover, for every functional program, there is a corresponding object-oriented program derived from the functional program using appropriate design patterns. The resulting OO program is still functional in the sense that all data objects are immutable. In our second semester course, we leverage our students understanding of functional design to teach object-oriented design using design patterns. We show students that the data-directed approach to program design taught in the first course applies equally well to writing object-oriented programs. Design patterns provide standard templates for expressing common data definitions and operations that process them in object-oriented form. We begin by teaching the union (composite without recursion), composite, interpreter, singleton, command, factory method, and visitor patterns. Students learn that there is an OO analog for every abstraction in FP. In Java, the connection is particularly compelling because Java fully supports closures in the form of inner classes. Once students have mastered &quot;functional programming &quot; in Java, we introduce object mutation using the state, strategy, iterator, observer, and model-view-controller patterns. We also show students how OOP facilitates code factoring and re-use.

Cited by 0

Advisors:

Yoshimi Takano, Arsenii Rudich · 2006

Prof. Dr. Peter MüllerOwnership is a powerful concept to structure the object store and to control aliasing and modifications of objects. Most extant ownership models do not support dynamic ownership transfers, which renders some object oriented-programming idioms inexpressible. Examples include the Abstract Factory design pattern and merging the representations of two linked lists. This report presents a solution to extend the Universe type system with

Cited by 0