Information Modeling Aspects of Software Development

The distinction between the modeling of information and the modeling of data in the creation of automated systems has historically been important because the development tools available to programmers have been wedded to machine oriented data types and processes. However, advances in software engineering, particularly the move toward data abstraction in software design, allow activities reasonably described as information modeling to be performed in the software creation process. An examination of the evolution of programming languages and development of general programming paradigms, including object-oriented design and implementation, suggests that while data modeling will necessarily continue to be a programmer's concern, more and more of the programming process itself is coming to be characterized by information modeling activities.     

An architecture for generic extensions

We examine what is necessary to allow generic libraries to be used naturally in a multi-language, potentially distributed environment. Language-neutral library interfaces usually do not support the full range of programming idioms that are available when a library is used natively. We investigate how to structure the language bindings of the neutral interface to achieve a better expressibility and code re-use. We furthermore address how language-neutral interfaces can be extended with import bindings to recover the desired programming idioms. We also address the question of how these extensions can be organized to minimize the performance overhead that arises from using objects in manners not anticipated by the original library designers. Our approach is to treat a library as a software component and to view the problem as one of component extension. We use C++ as an example of a mature language, with libraries using a variety of patterns, and use the Standard Template Library as an example of a complex library for which efficiency is important. By viewing the library extension problem as one of component organization, we enhance software composibility, hierarchy maintenance and architecture independence.     

Approximate clustering in very large relational data

Different extensions of fuzzy c‐means (FCM) clustering have been developed to approximate FCM clustering in very large (unloadable) image (eFFCM) and object vector (geFFCM) data. Both extensions share three phases: (1) progressive sampling of the VL data, terminated when a sample passes a statistical goodness of fit test; (2) clustering with (literal or exact) FCM; and (3) noniterative extension of the literal clusters to the remainder of the data set. This article presents a comparable method for the remaining case of interest, namely, clustering in VL relational data. We will propose and discuss each of the four phases of eNERF and our algorithm for this last case: (1) finding distinguished features that monitor progressive sampling, (2) progressively sampling a square N × N relation matrix R_N until an n × n sample relation R_n passes a statistical test, (3) clustering R_n with literal non‐Euclidean relational fuzzy c‐means, and (4) extending the clusters in R_n to the remainder of the relational data. The extension phase in this third case is not as straightforward as it was in the image and object data cases, but our numerical examples suggest that eNERF has the same approximation qualities that eFFCM and geFFCM do. © 2006 Wiley Periodicals, Inc. Int J Int Syst 21: 817–841, 2006.     

LibVM: an architecture for shared library sandboxing

Many software applications extend their functionality by dynamically loading libraries into their allocated address space. However, shared libraries are also often of unknown provenance and quality and may contain accidental bugs or, in some cases, deliberately malicious code. Most sandboxing techniques that address these issues require recompilation of the libraries using custom tool chains, require significant modifications to the libraries, do not retain the benefits of single address space programming, do not completely isolate guest code, or incur substantial performance overheads. In this paper, we present LibVM, a sandboxing architecture for isolating libraries within a host application without requiring any modifications to the shared libraries themselves, while still retaining the benefits of a single address space and also introducing a system call inter‐positioning layer that allows complete arbitration over a shared library's functionality. We show how to utilize contemporary hardware‐virtualization support towards this end with reasonable performance overheads, and, in the absence of such hardware support, our model can also be implemented using a software‐based mechanism. We ensure that our implementation conforms as closely as possible to existing shared library manipulation functions, minimizing the amount of effort needed to apply such isolation to existing programs. Our experimental results show that it is easy to gain immediate benefits in scenarios where the goal is to guard the host application against unintentional programming errors when using shared libraries, as well as in more complex scenarios, where a shared library is suspected of being actively hostile. In both cases, no changes are required to the shared libraries themselves. Copyright © 2014 John Wiley & Sons, Ltd.     

A novel full‐wave CAD for the design of tapered leaky‐wave antennas in hybrid waveguide printed‐circuit technology

This work presents a novel computer‐aided design (CAD) tool for the design of tapered leaky‐wave antennas (LWAs) in hybrid waveguide printed‐circuit technology. The software package is composed of several tools, which are connected together to provide a semi‐automated step‐by‐step design procedure. The design procedure is presented and the different tools are described, together with the involved theory, leading to the design of tapered LWAs. A practical taper design is performed, and comparisons with simulations using commercial software (HFSS) are presented for validation purposes. Due to the full‐wave nature of the technique used in the analysis engine, excellent agreement is shown between the proposed 2D‐based approach, and 3D HFSS results. Also, the analysis procedure is fast, thus leading to semi‐automated designs that are not affordable with common 3D optimization techniques. © 2006 Wiley Periodicals, Inc. Int J RF and Microwave CAE, 2006.     

GridFOR: A Domain Specific Language for Parallel Grid-Based Applications

To ease the programming burden and to make parallel programs more maintainable, computational scientists and engineers currently have the options to use software libraries, templates, and general purpose language extensions to compose their application programs. These existing options, unfortunately, have considerable limitations with compatibility, expressive power and delivered performance. To address these issues, we design a domain specific language, GridFOR, for computational problems defined over regular geometric grids. This language allows the programmer to first implement an algorithm on simple data structures, as commonly illustrated in textbooks or papers. The programmer then specifies transformations to extend the algorithm for complex data structures required by the target applications. We build a compiler to automatically translate a GridFOR program to a parallel Fortran version with Message Passing Interface calls. Several optimization techniques are implemented in our compiler to enhance the program speed.     

A theory of independent fuzzy probability for system reliability

Fuzzy fault trees provide a powerful and computationally efficient technique for developing fuzzy probabilities based on independent inputs. The probability of any event that can be described in terms of a sequence of independent unions, intersections, and complements may be calculated by a fuzzy fault tree. Unfortunately, fuzzy fault trees do not provide a complete theory: many events of substantial practical interest cannot be described only by independent operations. Thus, the standard fuzzy extension (based on fuzzy fault trees) is not complete since not all events are assigned a fuzzy probability. Other complete extensions have been proposed, but these extensions are not consistent with the calculations from fuzzy fault trees. We propose a new extension of crisp probability theory. Our model is based on n independent inputs, each with a fuzzy probability. The elements of our sample space describe exactly which of the n input events did and did not occur. Our extension is complete since a fuzzy probability is assigned to every subset of the sample space. Our extension is also consistent with all calculations that can be arranged as a fault tree. Our approach allows the reliability analyst to develop complete and consistent fuzzy reliability models from existing crisp reliability models. This allows a comprehensive analysis of the system. Computational algorithms are provided both to extend existing models and develop new models. The technique is demonstrated on a reliability model of a three-stage industrial process     

On the optimum pyramidal‐horn design methods

In this article the optimum pyramidal‐horn design methods are considered. The validity of comparing the different methods with respect to design accuracy is examined in light of the fundamental accuracy limits of Schelkonoff's horn‐gain formulas. © 2006 Wiley Periodicals, Inc. Int J RF and Microwave CAE, 2006.     

Closed‐form approach to design distributed matching networks for high‐frequency amplifiers

Based on the use of distributed lossless elements, a closed‐form synthesis for double‐frequency‐matching networks is introduced with an emphasis on the design of high‐frequency amplifiers. Three different circuit conditions are considered and design relationships are provided and discussed. Finally, the proposed approach, which uses the circle method, is successfully employed to design a Ka‐band (26–32 GHz) linear amplifier with gain equal to 8 dB and return loss greater than 10 dB for the considered band. © 2006 Wiley Periodicals, Inc. Int J RF and Microwave CAE, 2006.     

A language for generic programming in the large

Generic programming is an effective methodology for developing reusable software libraries. Many programming languages provide generics and have features for describing interfaces, but none completely support the idioms used in generic programming. To address this need we developed the language G. The central feature of G is the concept, a mechanism for organizing constraints on generics that is inspired by the needs of modern C++ libraries. G provides modular type checking and separate compilation (even of generics). These characteristics support modular software development, especially the smooth integration of independently developed components. In this article we present the rationale for the design of G and demonstrate the expressiveness of G with two case studies: porting the Standard Template Library and the Boost Graph Library from C++ to G. The design of G shares much in common with the concept extension proposed for the next C++ Standard (the authors participated in its design) but there are important differences described in this article.     

Design and evaluation of C++ open multi-methods

Multiple dispatch-the selection of a function to be invoked based on the dynamic type of two or more arguments-is a solution to several classical problems in object-oriented programming. Open multi-methods generalize multiple dispatch towards open-class extensions, which improve separation of concerns and provisions for retroactive design. We present the rationale, design, implementation, performance, programming guidelines, and experiences of working with a language feature, called open multi-methods, for C++. Our open multi-methods support both repeated and virtual inheritance. Our call resolution rules generalize both virtual function dispatch and overload resolution semantics. After using all information from argument types, these rules can resolve further ambiguities by using covariant return types. Care was taken to integrate open multi-methods with existing C++ language features and rules. We describe a model implementation and compare its performance and space requirements to existing open multi-method extensions and work-around techniques for C++. Compared to these techniques, our approach is simpler to use, catches more user mistakes, and resolves more ambiguities through link-time analysis, is comparable in memory usage, and runs significantly faster. In particular, the runtime cost of calling an open multi-method is constant and less than the cost of a double dispatch (two virtual function calls). Finally, we provide a sketch of a design for open multi-methods in the presence of dynamic loading and linking of libraries.     

On model typing

Where object-oriented languages deal with objects as described by classes, model-driven development uses models, as graphs of interconnected objects, described by metamodels. A number of new languages have been and continue to be developed for this model-based paradigm, both for model transformation and for general programming using models. Many of these use single-object approaches to typing, derived from solutions found in object-oriented systems, while others use metamodels as model types, but without a clear notion of polymorphism. Both of these approaches lead to brittle and overly restrictive reuse characteristics. In this paper we propose a simple extension to object-oriented typing to better cater for a model-oriented context, including a simple strategy for typing models as a collection of interconnected objects. We suggest extensions to existing type system formalisms to support these concepts and their manipulation. Using a simple example we show how this extended approach permits more flexible reuse, while preserving type safety.     

An EM‐circuit‐ANN co‐modeling approach for RF module design

A new co‐modeling technique dedicated to RF module design and optimization is described. This approach is based on combined EM, circuit, and artificial neural network simulations. Generic segments are parameterized in geometry, physical properties and frequency by analytical models and are integrated into commercial circuit software. This co‐modeling combines speed and flexibility of circuit simulators and accuracy of EM‐based simulators. © 2007 Wiley Periodicals, Inc. Int J RF and Microwave CAE, 2008.     

Generic Programming and High-Performance Libraries

Generic programming is an especially attractive paradigm for developing libraries for high-performance computing because it simultaneously emphasizes generality and efficiency. In the generic programming approach, interfaces are based on sets of specified requirements on types, rather than on any particular types, allowing algorithms to inter-operate with any data types meeting the necessary requirements. These sets of requirements, known as concepts, can specify syntactic as well as semantic requirements. Besides providing a powerful means of describing interfaces to maximize software reuse, concepts provide a uniform mechanism for more closely coupling libraries with compilers and for effecting domain-specific library-based compiler extensions. To realize this goal however, programming languages and their associated tools must support concepts as first-class constructs. In this paper we advocate better syntactic and semantic support to make concepts first-class and present results demonstrating the kinds of improvements that are possible with static checking, compiler optimization, and algorithm correctness proofs for generic libraries based on concepts.     

Normalization and lossless join decomposition of similarity‐based fuzzy relational databases

Fuzzy relational database models generalize the classical relational database model by allowing uncertain and imprecise information to be represented and manipulated. In this article, we introduce fuzzy extensions of the normal forms for the similarity‐based fuzzy relational database model. Within this framework of fuzzy data representation, similarity, conformance of tuples, the concept of fuzzy functional dependencies, and partial fuzzy functional dependencies are utilized to define the fuzzy key notion, transitive closures, and the fuzzy normal forms. Algorithms for dependency preserving and lossless join decompositions of fuzzy relations are also given. We include examples to show how normalization, dependency preserving, and lossless join decomposition based on the fuzzy functional dependencies of fuzzy relation are done and applied to some real‐life applications. © 2004 Wiley Periodicals, Inc. Int J Int Syst 19: 885–917, 2004.     

Tabling for non‐monotonic programming

Non‐monotonic extensions add power to logic programs. However, the main logic programming language, Prolog, is widely recognized as inadequate to implement these extensions due to its weak termination and complexity properties. By extending Prolog’s SLD resolution with tabling, Prolog can be improved in several ways. Tabling can allow a logic programming system to compute the well‐founded semantics for programs with bounded term depth, and to do so with polynomial data complexity. By exploiting these properties, tabling allows a variety of non‐monotonic extensions to be efficiently implemented, and used to solve practical problems. In this paper we describe tabling as it is implemented in the XSB system and show how it can be used to construct meta‐interpreters (or preprocessors) for two sample formalisms: the Well‐Founded Semantics with Explicit Negation, and Generalized Annotated Logic Programs. We also describe how non‐monotonic extensions are used in practical applications such as psychiatric diagnosis, extraction of information from poorly structured textual data, and model checking. This revised version was published online in June 2006 with corrections to the Cover Date.     

Development of VHDL‐AMS neuro‐fuzzy behavioral models for RF/microwave passive components

The new generation of System‐on‐Chip (SoC) incorporates digital, analogue, RF/microwave and mixed‐signal components. Such circuits impose to reconsider the traditional design methods. Mixed‐signal designers need novel design methodologies which will have to include accurate behavioral libraries of devices and processes into hierarchical design flows. Thus, this paper describes a behavioral modeling approach which generates neuro‐fuzzy‐based models for RF/microwave devices. The models, so obtained, can be easily integrated into a VHDL‐AMS simulator. This modeling approach is applied to a microwave tunable phase shifter and it is illustrated by the development of a VHDL‐AMS model library for RF/microwave applications. © 2007 Wiley Periodicals, Inc. Int J RF and Microwave CAE, 2007.     

基于源代码分析的嵌入式软件高速仿真

现有嵌入式软件仿真工具的应用受到仿真速度等不足的限制。在一些领域中,此处介绍的方法将是更好的解决方案。该方法使用自行开发的分析器将嵌入式软件的源代码转换为ANSIC／C＋＋代码,并将其与仿真专用的函数库编译连接。最终生成的PC上的可执行程序就是目标嵌入式软件及其硬件平台的模型。由于具备可以达到目标系统运行速度数百倍的仿真速度,和合理的仿真精确度,该方法可以在设计空间探索阶段和算法级嵌入式编程中取代常用的开发工具包以及ISS,并有效缩短开发周期。     

Dual models for possibilistic regression analysis

Upper and lower regression models (dual possibilistic models) are proposed for data analysis with crisp inputs and interval or fuzzy outputs. Based on the given data, the dual possibilistic models can be derived from upper and lower directions, respectively, where the inclusion relationship between these two models holds. Thus, the inherent uncertainty existing in the given phenomenon can be approximated by the dual models. As a core part of possibilistic regression, firstly possibilistic regression for crisp inputs and interval outputs is considered where the basic dual linear models based on linear programming, dual nonlinear models based on linear programming and dual nonlinear models based on quadratic programming are systematically addressed, and similarities between dual possibilistic regression models and rough sets are analyzed in depth. Then, as a natural extension, dual possibilistic regression models for crisp inputs and fuzzy outputs are addressed.     

Parallel Programming of Multi-processor SoC: A HW–SW Interface Perspective

For the design of classic computers the parallel programming concept is used to abstract HW/SW interfaces during high level specification of application software. The software is then adapted to existing multiprocessor platforms using a low level software layer that implements the programming model. Unlike classic computers, the design of heterogeneous MPSoC includes also building the processors and other kind of hardware components required to execute the software. In this case, the programming model hides both hardware and software refinements. This paper deals with parallel programming models to abstract both hardware and software interfaces in the case of heterogeneous MPSoC design. Different abstraction levels will be needed. For the long term, the use of higher level programming models will open new vistas for optimization and architecture exploration like CPU/RTOS tradeoffs.