202,644 research outputs found

    An engineering approach to automatic programming

    Get PDF
    An exploratory study of the automatic generation and optimization of symbolic programs using DECOM - a prototypical requirement specification model implemented in pure LISP was undertaken. It was concluded, on the basis of this study, that symbolic processing languages such as LISP can support a style of programming based upon formal transformation and dependent upon the expression of constraints in an object-oriented environment. Such languages can represent all aspects of the software generation process (including heuristic algorithms for effecting parallel search) as dynamic processes since data and program are represented in a uniform format

    Automata learning algorithms and processes for providing more complete systems requirements specification by scenario generation, CSP-based syntax-oriented model construction, and R2D2C system requirements transformation

    Get PDF
    Systems, methods and apparatus are provided through which in some embodiments, automata learning algorithms and techniques are implemented to generate a more complete set of scenarios for requirements based programming. More specifically, a CSP-based, syntax-oriented model construction, which requires the support of a theorem prover, is complemented by model extrapolation, via automata learning. This may support the systematic completion of the requirements, the nature of the requirement being partial, which provides focus on the most prominent scenarios. This may generalize requirement skeletons by extrapolation and may indicate by way of automatically generated traces where the requirement specification is too loose and additional information is required

    Objects and polymorphism in system programming languages: a new approach

    Get PDF
    A low-level data structure always has a predefined representation which does not fit into an object of traditional object-oriented languages, where explicit type tag denotes its dynamic type. This is the main reason why the advanced features of object-oriented programming cannot be fully used at the lowest level. On the other hand, the hierarchy of low-level data structures is very similar to class-trees, but instead of an explicit tag-field the value of the object determines its dynamic type. Another peculiar requirement in system programming is that some classes have to be polymorphic by-value with their ancestor: objects must fit into the space of a superclass instance. In our paper we show language constructs which enable the system programmer to handle all data structures as objects, and exploit the advantages of object-oriented programming even at the lowest level. Our solution is based on Predicate Dispatching, but adopted to the special needs of system programming. The techniques we show also allow fo r some classes to be polymorphic by-value with their super. We also describe how to implement these features without losing modularity

    No Code AI: Automatic generation of Function Block Diagrams from documentation and associated heuristic for context-aware ML algorithm training

    Full text link
    Industrial process engineering and PLC program development have traditionally favored Function Block Diagram (FBD) programming over classical imperative style programming like the object oriented and functional programming paradigms. The increasing momentum in the adoption and trial of ideas now classified as 'No Code' or 'Low Code' alongside the mainstream success of statistical learning theory or the so-called machine learning is redefining the way in which we structure programs for the digital machine to execute. A principal focus of 'No Code' is deriving executable programs directly from a set of requirement documents or any other documentation that defines consumer or customer expectation. We present a method for generating Function Block Diagram (FBD) programs as either the intermediate or final artifact that can be executed by a target system from a set of requirement documents using a constrained selection algorithm that draws from the top line of an associated recommender system. The results presented demonstrate that this type of No-code generative model is a viable option for industrial process design.Comment: 2022 7th International Conference on Mechanical Engineering and Robotics Researc

    Object-Oriented Analysis: A Decision-Driven Approach

    Get PDF
    Recently, many object-oriented analysis and design approaches (OOADs) have been proposed. This research boom may be attributed to the success of applying object-oriented programming (OOP) in embedded systems and systems software. However, object-oriented analysis (OOA) does not seem as successful as object-oriented design (OOD) or OOP [3]. Whereas the extant OOADs claim to perform systems analysis, this goal is seldom fulfilled [3]. Systems analysis consists of two kinds of activities: requirement analysis (problem analysis) and requirement specification (product description) [1]. During therequirement analysis, analysts aim to understand the problem and identify all possible constraints on the problem\u27s solution through observations, interviews, and discussions with experts in the problem domain. The requirement analysis activity analyzes the requirement space of a problem domain. Here, the requirement space is defined as the range of all possible user needs and constraints in a problem domain. Requirement specification, on the other hand, is intended to resolve conflicting views, to eliminate inconsistencies and ambiguities, and to document some particular requirement which describes the expected behavior of the future system. As Hoydalsvik et al [3] indicate, the extant OOADs are target-system oriented. A target-system oriented OOA aims to construct an object -oriented system and represents the requirement in a way more consistent with the design issues than with the users\u27 perception of the problem domain. In other words, it concentrates on a solution and not on understanding the problem. Finding objects and classes is the prevalent trend in the pure OOA. However, as Rubin et al [5] note, there are several problems in searching for objects: 1) The availability of a written requirement specification is usually assumed. Assuming a narrative specification is accessible, an OOAD searches for nouns as objects and for verbs as methods. This approach ignores that a written specification is barely available; even if it is available, ambiguities of text, synonyms, and homonyms are not unusual, 2) there is a strong bias toward the tangible aspects of a problem, and 3) it tends to incorporate all tangible objects of the analysis results. In order to address these shortcomings, an OOA approach should include a systematic procedure to understand the problem and the organization before finding the objects. Decision making is a major activity of an organization [6]. This article proposes a decision-driven OOA approach, which consists of a set of well-organized guidelines and procedures, focuses on the understanding of organizations through the analysis of decision making, and helps derive requirement specification in the form of object models. In particular, this article aims to address the following issues: •What decision making model is more appropriate for understanding the organization? •What aspects of decision making should be captured for understanding the organization? •What steps should an OOA approach have? •What mechanisms can help verify and validate the process of OOA?We will briefly review several OOADs in the next section. The proposed approach will be discussed in the following sectio

    Object-oriented modelling with unified modelling language 2.0 for simple software application based on agile methodology

    Full text link
    Unified modelling language (UML) 2.0 introduced in 2002 has been developing and influencing object-oriented software engineering and has become a standard and reference for information system analysis and design modelling. There are many concepts and theories to model the information system or software application with UML 2.0, which can make ambiguities and inconsistencies for a novice to learn to how to model the system with UML especially with UML 2.0. This article will discuss how to model the simple software application by using some of the diagrams of UML 2.0 and not by using the whole diagrams as suggested by agile methodology. Agile methodology is considered as convenient for novices because it can deliver the information technology environment to the end-user quickly and adaptively with minimal documentation. It also has the ability to deliver best performance software application according to the customer's needs. Agile methodology will make simple model with simple documentation, simple team and simple tools.Comment: 15 pages, 30 figure

    Use cases in software development: an investigation in its roles and values

    Get PDF
    This research work identifies the roles and values of USE CASES in software development, and analysed the concept of USE CASES critically in other to ascertain their usefulness in achieving a user’s requirement when applied to a system development methodology. We examined the major considerations for deploying advanced UML modelling by considering the best approach for a programmer to get to the source code by putting the right aspect of the UML to work at the right stage of a system life cycle in an object (OO) oriented analysis and design practice. research has found out that to achieve a successful object oriented programming design and implementation, an analyst should strive to drive an OO software design from USE CASE

    Diligence of Domain Engineering in Accounting Management System

    Get PDF
    This paper presents on domain feature modeling, domain architecture design and domain implementation in an enterprise. This paper demonstrates the accounting management feature modeling based on the extended (Feature-Oriented Domain Analysis) FODA method and system architecture of accounting management domain, integrates Aspect Object Oriented Programming technology with domain implementation, and designs a whippersnapper AOP framework based on the object proxy pattern to separates crosscutting concerns in the domain implementation phrase. Research result shows this method can effectively seal insulate and abstract variability in requirements of accounting management domain, instruct the designing and implementation of accounting management components, get the requirement of software reuse, resource sharing and collaboration in accounting management domain
    corecore