The Experts below are selected from a list of 18555 Experts worldwide ranked by ideXlab platform

Ying Zou - One of the best experts on this subject based on the ideXlab platform.

  • quality driven software migration of Procedural Code to object oriented design
    International Conference on Software Maintenance, 2005
    Co-Authors: Ying Zou
    Abstract:

    In the context of software maintenance, legacy software systems are continuously re-engineered in order to correct errors, provide new functionality, or port them into modern platforms. However, software re-engineering activities should not occur in a vacuum, and it is important to incorporate non-functional requirements as part of the re-engineering process. We present an incremental reengineering framework that allows for quality requirements to be modeled as soft-goals, and transformations to be applied selectively towards achieving specific quality requirements for the target system. To deal with large software systems, we decompose the system into a collection of smaller clusters. The reengineering framework can be applied incrementally to each of these clusters and results are assembled to produce the final system.

  • ICSM - Quality driven software migration of Procedural Code to object-oriented design
    21st IEEE International Conference on Software Maintenance (ICSM'05), 2005
    Co-Authors: Ying Zou
    Abstract:

    In the context of software maintenance, legacy software systems are continuously re-engineered in order to correct errors, provide new functionality, or port them into modern platforms. However, software re-engineering activities should not occur in a vacuum, and it is important to incorporate non-functional requirements as part of the re-engineering process. We present an incremental reengineering framework that allows for quality requirements to be modeled as soft-goals, and transformations to be applied selectively towards achieving specific quality requirements for the target system. To deal with large software systems, we decompose the system into a collection of smaller clusters. The reengineering framework can be applied incrementally to each of these clusters and results are assembled to produce the final system.

  • a framework for migrating Procedural Code to object oriented platforms
    Asia-Pacific Software Engineering Conference, 2001
    Co-Authors: Ying Zou, Kostas Kontogiannis
    Abstract:

    With the rapid growth of the Internet and pervasive computing activities, the migration of back-end legacy systems to network centric environments has become a focal point for researchers and practitioners alike. To leverage back-end legacy services into Web-enabled environments, this paper proposes an incremental and iterative migration framework where legacy Procedural source Code is reengineered into an object-oriented platform. The reengineering framework allows for the representation of the legacy source in the form of XML based annotated abstract syntax trees. Consequently, the extraction of an object-oriented model from the original source Code is based on the analysis of source Code features in the original system that can be used to identify classes, associations, aggregations, and polymorphic patterns in the new target system.

  • APSEC - A framework for migrating Procedural Code to object-oriented platforms
    Proceedings Eighth Asia-Pacific Software Engineering Conference, 1
    Co-Authors: Ying Zou, Kostas Kontogiannis
    Abstract:

    With the rapid growth of the Internet and pervasive computing activities, the migration of back-end legacy systems to network centric environments has become a focal point for researchers and practitioners alike. To leverage back-end legacy services into Web-enabled environments, this paper proposes an incremental and iterative migration framework where legacy Procedural source Code is reengineered into an object-oriented platform. The reengineering framework allows for the representation of the legacy source in the form of XML based annotated abstract syntax trees. Consequently, the extraction of an object-oriented model from the original source Code is based on the analysis of source Code features in the original system that can be used to identify classes, associations, aggregations, and polymorphic patterns in the new target system.

David Bednarek - One of the best experts on this subject based on the ideXlab platform.

  • Transforming Procedural Code for Streaming Environments
    2017 25th Euromicro International Conference on Parallel Distributed and Network-based Processing (PDP), 2017
    Co-Authors: Michal Brabec, David Bednarek
    Abstract:

    Streaming environments and similar parallel platforms are widely used in image, signal, or general data processing as a means of achieving high performance. Unfortunately, they are often associated with specific programming languages and, thus, hardly accessible for non-experts. In this paper, we present a framework for transformation of a C# Procedural Code to a Hybrid Flow Graph - a novel intermediate Code which employs the streaming paradigm and can be further converted into a streaming application. This approach will allow creating streaming applications or their parts using a widely known imperative language instead of an intricate language specific to streaming. In this paper, we focus on the transformation of control flow which represents the main difference between Procedural Code, driven by control flow constructs, and streaming environments, driven by data. Since the use of a streaming platform automatically enables parallelism and vectorization, we were able to demonstrate that the streaming applications generated by our method may outperform their original C# implementation.

  • PDP - Transforming Procedural Code for Streaming Environments
    2017 25th Euromicro International Conference on Parallel Distributed and Network-based Processing (PDP), 2017
    Co-Authors: Michal Brabec, David Bednarek
    Abstract:

    Streaming environments and similar parallel platforms are widely used in image, signal, or general data processing as a means of achieving high performance. Unfortunately, they are often associated with specific programming languages and, thus, hardly accessible for non-experts. In this paper, we present a framework for transformation of a C# Procedural Code to a Hybrid Flow Graph – a novel intermediate Code which employs the streaming paradigm and can be further converted into a streaming application. This approach will allow creating streaming applications or their parts using a widely known imperative language instead of an intricate language specific to streaming. In this paper, we focus on the transformation of control flow which represents the main difference between Procedural Code, driven by control flow constructs, and streaming environments, driven by data. Since the use of a streaming platform automatically enables parallelism and vectorization, we were able to demonstrate that the streaming applications generated by our method may outperform their original C# implementation.

  • hybrid flow graphs towards the transformation of sequential Code into parallel pipeline networks
    ITAT, 2015
    Co-Authors: Michal Brabec, David Bednarek
    Abstract:

    Transforming Procedural Code for execution by specialized parallel platforms requires a model of compu- tation sufficiently close to both the sequential program- ming languages and the target parallel environment. In this paper, we present Hybrid Flow Graphs, encompassing both control flow and data flow in a unified, pipeline based model of computation. Besides the definition of the Hy- brid Flow Graph, we introduce a formal framework based on graph rewriting, used for the specification of Hybrid Flow Graph semantics as well as for the proofs of cor- rectness of the associated Code transformations. As a for- malism particularly close to pipeline-based runtime envi- ronments which include many modern database engines, the Hybrid Flow Graphs may become a powerful means for the automatic parallelization of sequential Code under these environments.

  • Procedural Code representation in a flow graph
    DATESO, 2015
    Co-Authors: Michal Brabec, David Bednarek
    Abstract:

    Modern scientific computing often combines extensive calcu- lation with complex structure of data; however, the programming method- ologies and languages of high-performance computing significantly dier from those of databases. This impedance mismatch leads many projects to the use of either primitive (like JSON) or overly general (like dis- tributed file systems) methods of data access, ignoring the decades of development in database technology. In this paper, we investigate the possibility to represent Procedural Code fragments using a network of op- erators similar to query plans used in relational database systems. Such a unified representation forms the necessary step towards an integrated computational-database platform. We propose a flow graph representa- tion that allows us to analyze, transform and optimize applications more eciently and without additional data. Along with the graph, we de- signed an algorithm that transforms a Procedural Code into the graph.

  • DATESO - Procedural Code Representation in a Flow Graph
    2015
    Co-Authors: Michal Brabec, David Bednarek
    Abstract:

    Modern scientific computing often combines extensive calcu- lation with complex structure of data; however, the programming method- ologies and languages of high-performance computing significantly dier from those of databases. This impedance mismatch leads many projects to the use of either primitive (like JSON) or overly general (like dis- tributed file systems) methods of data access, ignoring the decades of development in database technology. In this paper, we investigate the possibility to represent Procedural Code fragments using a network of op- erators similar to query plans used in relational database systems. Such a unified representation forms the necessary step towards an integrated computational-database platform. We propose a flow graph representa- tion that allows us to analyze, transform and optimize applications more eciently and without additional data. Along with the graph, we de- signed an algorithm that transforms a Procedural Code into the graph.

Francois Fages - One of the best experts on this subject based on the ideXlab platform.

  • CSCLP - Procedural Code generation vs static expansion in modelling languages for constraint programming
    Lecture Notes in Computer Science, 2011
    Co-Authors: Julien Martin, Thierry Martinez, Francois Fages
    Abstract:

    To make constraint programming easier to use by the nonprogrammers, a lot of work has been devoted to the design of frontend modelling languages using logical and algebraic notations instead of programming constructs. The transformation to an executable constraint program can be performed by fundamentally two compilation schemas: either by a static expansion of the model in a flat constraint satisfaction problem (e.g. Zinc, Rules2CP, Essence) or by generation of Procedural Code (e.g. OPL, Comet). In this paper, we compare both compilation schemas. For this, we consider the rule-based modelling language Rules2CP with its static exansion mechanism and describe with a formal system a new compilation schema which proceeds by generation of Procedural Code. We analyze the complexity of both compilation schemas, and present some performance figures of both the compilation process and the generated Code on a benchmark of scheduling and bin packing problems.

  • Procedural Code generation vs static expansion in modelling languages for constraint programming
    Lecture Notes in Computer Science, 2009
    Co-Authors: Julien Martin, Thierry Martinez, Francois Fages
    Abstract:

    To make constraint programming easier to use by the nonprogrammers, a lot of work has been devoted to the design of frontend modelling languages using logical and algebraic notations instead of programming constructs. The transformation to an executable constraint program can be performed by fundamentally two compilation schemas: either by a static expansion of the model in a flat constraint satisfaction problem (e.g. Zinc, Rules2CP, Essence) or by generation of Procedural Code (e.g. OPL, Comet). In this paper, we compare both compilation schemas. For this, we consider the rule-based modelling language Rules2CP with its static exansion mechanism and describe with a formal system a new compilation schema which proceeds by generation of Procedural Code. We analyze the complexity of both compilation schemas, and present some performance figures of both the compilation process and the generated Code on a benchmark of scheduling and bin packing problems.

Yishai Feldman - One of the best experts on this subject based on the ideXlab platform.

  • automatic recovery of statecharts from Procedural Code
    Automated Software Engineering, 2012
    Co-Authors: Moria Abadi, Yishai Feldman
    Abstract:

    We have developed a static-analysis algorithm that extracts statecharts from Procedural implementations of state machines. The extracted statecharts are semantically-equivalent to the original program, and can be used for further development instead of the Procedural Code. We have implemented this algorithm in a tool called StatRec. We report on the results of running StatRec on a number of examples, including an implementation of the TCP protocol.

  • ASE - Automatic recovery of statecharts from Procedural Code
    Proceedings of the 27th IEEE ACM International Conference on Automated Software Engineering - ASE 2012, 2012
    Co-Authors: Moria Abadi, Yishai Feldman
    Abstract:

    We have developed a static-analysis algorithm that extracts statecharts from Procedural implementations of state machines. The extracted statecharts are semantically-equivalent to the original program, and can be used for further development instead of the Procedural Code. We have implemented this algorithm in a tool called StatRec. We report on the results of running StatRec on a number of examples, including an implementation of the TCP protocol.

Lidong Zhou - One of the best experts on this subject based on the ideXlab platform.

  • Spotting Code Optimizations in Data-Parallel Pipelines through PeriSCOPE
    IEEE Transactions on Parallel and Distributed Systems, 2015
    Co-Authors: Xuepeng Fan, Zhenyu Guo, Jiaxing Zhang, Hucheng Zhou, Sean Mcdirmid, Wei Lin, Jingren Zhou, Hai Jin, Xiaofei Liao, Lidong Zhou
    Abstract:

    To minimize the amount of data-shuffling I/O that occurs between the pipeline stages of a distributed data-parallel program, its Procedural Code must be optimized with full awareness of the pipeline that it executes in. Unfortunately, neither pipeline optimizers nor traditional compilers examine both the pipeline and Procedural Code of a data-parallel program so programmers must either hand-optimize their program across pipeline stages or live with poor performance. To resolve this tension between performance and programmability, this paper describes PeriSCOPE, which automatically optimizes adata-parallel program’s Procedural Code in the context of data flow that is reconstructed from the program’s pipeline topology. Such optimizations eliminate unnecessary Code and data, perform early data filtering, and calculate small derived values (e.g., predicates) earlier in the pipeline, so that less data—sometimes much less data—is transferred between pipeline stages. PeriSCOPE further leverages symbolic execution to enlarge the scope of such optimizations by eliminating dead Code. We describe how PeriSCOPE is implemented and evaluate its effectiveness on real production jobs.

  • OSDI - Spotting Code optimizations in data-parallel pipelines through PeriSCOPE
    2012
    Co-Authors: Zhenyu Guo, Xuepeng Fan, Rishan Chen, Jiaxing Zhang, Hucheng Zhou, Sean Mcdirmid, Chang Liu, Wei Lin, Jingren Zhou, Lidong Zhou
    Abstract:

    To minimize the amount of data-shuffling I/O that occurs between the pipeline stages of a distributed data-parallel program, its Procedural Code must be optimized with full awareness of the pipeline that it executes in. Unfortunately, neither pipeline optimizers nor traditional compilers examine both the pipeline and Procedural Code of a data-parallel program so programmers must either hand-optimize their program across pipeline stages or live with poor performance. To resolve this tension between performance and programmability, this paper describes PeriSCOPE, which automatically optimizes a data-parallel program's Procedural Code in the context of data flow that is reconstructed from the program's pipeline topology. Such optimizations eliminate unnecessary Code and data, perform early data filtering, and calculate small derived values (e.g., predicates) earlier in the pipeline, so that less data--sometimes much less data--is transferred between pipeline stages. We describe how PeriSCOPE is implemented and evaluate its effectiveness on real production jobs.