Portable Character Processing in Fortran and Fixed Integer Environments

Many languages, including Fortran, and machines such as most minicomputers have little or no built-in character manipulation capability and yet are often required to process character information. This paper discusses the programming of character processing in such integer environments. Character representation, string-to-word coordinate transformation, packing, and unpacking using several arithmetic schemes are discussed with special attention to program portability. Several Fortran subroutines are presented culminating in BYTRAN, a set of portable Fortran subroutines that simulate the string structures and operators of the PL/I language.     

在Java中访问自动化COM组件

与其他编程语言相比，Java有很多优点，尽管如此。你常常希望在你的代码中访问其他语言写的应用或者程序库．尤其是COM组件。标准Java没有对COM提供支持，但是。你可以对自动化COM组件主要是COM组件的ldispatch接口进行封装，然后通过使用Java本地接口（JNI）采访问COM组件。     

在Java中访问自动化COM组件

与其他编程语言相比,Java有很多优点,尽管如此,你常常希望在你的代码中访问其他语言写的应用或者程序库,尤其是COM组件。标准Java没有对COM提供支持,但是,你可以对自动化COM组件主要是COM组件的Idispatch接口进行封装,然后通过使用Java本地接口(JNI)来访问COM组件。     

Pascal: An Overview

Pascal–even with its flaws–offers significant advantages over simplistic languages such as Fortran or Basic, without requiring the enormous resources of PL/I or Algol 68.     

Communication generation for aligned and cyclic(k) distributionsusing integer lattice

Optimizing communication is a key issue in generating efficient SPMD codes in compiling distributed arrays on data parallel languages, such as High Performance Fortran. In HPF, the array distribution may involve alignment and cyclic(k)-distribution such that the enumeration of the local set and the enumeration of the communication set exhibit regular patterns which can be modeled as integer lattices. In the special case of unit-strided alignment, many techniques of the communication set enumeration have been proposed, while in the general case of the non-unit-strided alignment, inspector-like run-time codes are needed to build repeating pattern table or to scan over local elements such that the communication set can be constructed. Unlike other works on this problem of the general alignment and cyclic(k) distribution, our approach derives an algebraic solution for such an integer lattice that models the communication set by using the Smith-Normal-Form analysis, therefore, efficient enumeration of the communication set can be generated. Based on the integer lattice, we also present our algorithm for the SPMD code generation. In our approach, when the parameters are known, the SPMD program can be efficiently constructed without any inspector-like run-time codes     

Patents: to file or not to file?

In the previous paper, the author discussed the three criteria for patentability: novelty, usefulness, and nonobviousness and the practical value of obtaining a patent in terms of discoverability - the ease with which infringement can be determined, and in terms of avoidance - the ease with which a potential user of someone's invention could achieve similar results without using that invention. In this paper, the author continues the discussion of the practical value of a patent. Suppose that you have decided that your invention is novel, useful, and nonobvious. Further, suppose that you have decided that your invention is unavoidable (that is, it is the only reasonable way to do whatever it does), and that infringement would be easily discoverable. The remaining questions as to whether to proceed with a patent application are: Who would be likely to use your invention? Based on your answer to #1, what is the value to you of owning the patent? How much will it cost you to obtain the patent? Will your patent stand up in court if it is challenged?.     

Fortran与C#混合编程在卫星测高中的应用

为了发挥Fortran易于科学计算的优点和C#在界面编写以及批量处理文件的优点,首先通过Fortran控制台程序编写相应算法的动态链接库,然后利用C#编写的界面程序调用在Fortran中生成的DLL文件,从而实现混合编程。详细阐述了两种语言混合编程的实现方法。通过利用卫星测高数据计算南海海域的垂线偏差,验证了该方法的正确性及优越性。通过混合编程,充分发挥两种计算机语言各自的优点,说明了可以利用混合编程的方法大批量自动化地处理卫星测高数据,同时该方法便于算法维护和升级。     

Who ya gonna call! You're on your own [software usability design]

The issue here is not whether discount techniques should be used; they are inevitable. The issue is, in trying to do the best job you can with the ridiculously limited resources provided you, what should you do? How confident should you be in the techniques you are using? A bad design may come back and bite you. When you choose a technique to use in a hurry, you are placing your professional reputation and perhaps your job on the line. You deserve to know four things about any technique that you apply. The hit rate: How many real problems will this technique uncover? The false-alarm rate: How many (and what sorts) of things will it falsely identify as problems (that may not exist, but are costly and time consuming to “fix”)? What does it miss? What types of problems (and how many) does this technique not discover? The correct rejections: How confident are you in your discount technique's ability to flag problems? Discount techniques are not a substitute for the potent combination of analytic and empirical methodologies that usability professionals can bring to bear in designing and evaluating an interface     

The “KISS” Principle

Abstract

To be consistent with the buzzword of current processing, I want to make this column as interactive as possible. You will find my personal e-mail address at the end of the text — you can communicate your thoughts on what I write, what subjects you would like to see explored, and pose questions as you see fit. Of course, you can also take shots as you feel the need (as if a person giving out an e- mail address does not expect that to happen!). However, if you have a problem with anything you read here (or do not read here), I will expect you to include suggestions as to what might be done to improve things and be more responsive to our readers. Sorry, we do not acknowledge griping for the sake of griping; leave your flamethrower at home.     

Do you know what your license allows?

Before you push a key to load a program and display it on your monitor, ask yourself this question: “Do I have the power to use this program?” Using software requires power-not physical or electrical power-but the legal power of authorized use. If you are not the program's author or owner, you can only obtain this power through a license-a legal document that states your rights regarding use of the program. This may include the right to use or operate the program as an end user; modify the program through deletions, additions or enhancements as a value-added reseller or original equipment manufacturer; or transfer the program to another as an aggregator, distributor or retailer. If you do not have the appropriate legal power, then your conduct is illegal. If you know that you do not have the appropriate legal power, then your conduct, which amounts to software piracy, is criminal     

Can you social engineer your way into your network?

At larger customer sites, I am frequently asked to see if I can get into a computer facility or asked to gain access to corporate assets. One of the more successful manners in which to do this is via social engineering. Social engineering, is, basically, lying your way into a facility. It takes a certain amount of self-confidence and the ability to talk your way out of situations where you might get caught. It also takes a certain amount of “on your feet” thinking so that you do not get into a situation where you are discovered too soon. The idea is to test the facilities in your purview without getting caught too soon, if at all, so that improvements can be made.     

Five strategies for overcoming obviousness

The author explained the various office actions that you are likely to see a patent examiner make (under legal sections 101-103 and 112) and briefly noted some other parts of the legal code that you are unlikely to encounter (legal sections 104, 105, and 113-122). In addition, the author mentioned the possibility of the examiner filing a restriction on your patent application. The two remaining sections, 102 and 103, address novelty and obviousness, respectively. Under section 102, the examiner cites a single reference to prior art that he claims is the same as your invention. That is, he makes the claim that your invention is not novel (new). This is usually cut and dried $he is either right, or he has misunderstood at least one of the inventions. Section 103 leaves you more wiggle room to argue, since it pertains to the murky area of obviousness. In a 103, the examiner cites not just one, but two or more references and claims two things: that combining the inventions in those multiple references will produce your invention; and that conceiving such a combination is obvious. In this column, the author explains five distinct dimensions in which you can argue to overcome a section 103 rejection. You may choose to argue in multiple dimensions, but if you do, make it clear at all times which dimension you are arguing, or your argument will be confusing     

Breaking the data ties that bind you

The typical enterprise's application portfolio links today's newer, multiplatform applications with legacy mainframe apps. These legacy relics were written in arcane languages few now understand, often contain more patches than source, and have poor, if any, documentation. Hard as they are to live with, you know your enterprise cannot live without them, they hold too much data. The author considers how reverse engineering can help by rescuing your priceless data from its retro prison     

Efficient Computation of Address Sequences in Data Parallel Programs Using Closed Forms for Basis Vectors

Arrays are mapped to processors through a two-step process—alignment followed by distribution—in data-parallel languages such as High Performance Fortran. This process of mapping creates disjoint pieces of the array that are locally owned by each processor. An HPF compiler that generates code for array statements must compute the sequence of local memory addresses accessed by each processor and the sequence of sends and receives for a given processor to access nonlocal data. In this paper, we present an approach to the address sequence generation problem using the theory of integer lattices. The set of elements referenced can be generated by integer linear combinations of basis vectors. Unlike other work on this problem, we derive closed form expressions for the basis vectors as a function of the mapping of data. Using these basis vectors and exploiting the fact that there is a repeating pattern in the access sequence, we derive highly optimized code that generates the pattern at runtime. The code generated uses table-lookup of the pattern. Experimental results show that our approach is faster than other solutions to this problem.     

Safe and simple software cost analysis

Simple software cost-analysis methods are readily available, but they aren't always safe. The simplest method is to base your cost estimate on the typical costs or productivity rates of your previous projects. That approach will work well if your new project doesn't have any cost-critical differences from those previous projects, but it won't be safe if some critical cost driver has degraded. Simple history-based software cost-analysis methods would be safer if you could identify which cost driver factors were likely to cause critical cost differences and estimate how much cost difference would result if a critical cost driver changed by a given degree. In this article, I provide a safe and simple method for doing both of these by using some cost-estimating relationships. COCOMO II is an updated and re-calibrated version of COCOMO (COnstructive COst MOdel). I also show how the COCOMO II cost drivers let you perform cost sensitivity and tradeoff analyses, and discuss how you can use similar methods with other software cost-estimation models     

Avoiding a middleware muddle

Middleware is a layer of software that enables communications between software components regardless of the programming language in which the components are developed, the protocols used to communicate between components, or the platforms on which the components execute. To make sense of the middleware morass and to select the middleware best for you, the author recommends the following steps when constructing your system: identify what type of communication must occur; identify the communications model you will use to implement that communication type; using your communications model, identify the types of middleware you will use to implement the communication; and evaluate candidate products. The author examines each step in detail     

Coarray-based load balancing on heterogeneous and many-core architectures

In order to reach challenging performance goals, computer architecture is expected to change significantly in the near future. Heterogeneous chips, equipped with different types of cores and memory, will force application developers to deal with irregular communication patterns, high levels of parallelism, and unexpected behavior.Load balancing among the heterogeneous compute units will be a critical task in order to achieve an effective usage of the computational power provided by such new architectures. In this highly dynamic scenario, Partitioned Global Address Space (PGAS) languages, like Coarray Fortran, appear a promising alternative to standard MPI programming that uses two-sided communications, in particular because of PGAS one-sided semantic and ease of programmability. In this paper, we show how Coarray Fortran can be used for implementing dynamic load balancing algorithms on an exascale compute node and how these algorithms can produce performance benefits for an Asian option pricing problem, running in symmetric mode on Intel Xeon Phi Knights Corner and Knights Landing architectures.     

A vector C and Fortran compiler for the FPS T-series: Experiences with compiling to occam I

We describe our implementation of C and Fortran preprocessors for the FPS T-series hypercube. The target of these preprocessors is the occam I language. We provide a brief overview of the INMOS transputer and the Weitek vector processing unit (VPU). These two units comprise one node of the T-series. Some depth of understanding of the VPU is required to fully appreciate the problems encountered in generating vector code. These complexities were not fully appreciated at the outset. The occam I language is briefly described. We focus on only those aspects of occam I which differ radically from C. The transformations used to preprocess C into occam I are discussed in detail. The special problems with the VPU both in terms of its (non)interface with occam I and in dealing with numerical programs is discussed separately. A lengthy discussion on the special techniques required for compilation is provided. C and Fortran are simply incompatible with the occam I model. We provide a catalogue of problems encountered. We emphasize that these problems are not so much with occam I but with preprocessing to occam I. We feel the CSP and occam I models are quite good for distributed processing. The ultimate message from this work should be seen in a larger context. Several languages—such as Ada and Modula-2—are being touted as the standards for the 1990s. These languages severely restrict parallel programming style; this may make saving dusty decks by preprocessing an impossibility.     

Why is technology transfer so hard?

If you were the vice president of software in a company with 10,000 software personnel, what would you do to make sure your software team had state-of-the-art tools and methodologies? At a more fundamental level, how would you and your staff even find out what they are and whether your current tools and methodologies are good, bad, or average? That is the crux of two major challenges to the software community: How do we evaluate tools and methods for effectiveness? How do we deploy better tools and methods once they have been identified? Unfortunately, the software industry lacks standard measurements and benchmarks for evaluating the effectiveness of programming tools and languages, design approaches, or almost any other kind of technology. Purchasing and acquisition decisions are often made on the basis of unsubstantiated vendor claims. Moreover, once a new tool or methodology is acquired, deployment is often slow. Tools are acquired without considering training needs, or if training is considered, it's not readily available due to schedule pressures     

RATSNO—an experiment in software adaptability

Adaptable programs are one of the benefits of structured programming. The adaptability of a program is the degree to which it can be transformed into another program that performs a similar, but slightly different, function. While it is clear that the aims of structured programming are best satisfied by the use of modern programming languages, a great number of programmers must use languages such as Fortran. To alleviate this situation, a number of preprocessors have been introduced that give Fortran a more structured facade. This paper describes an experiment performed to test the adaptability of programs written in RATFOR, one of these preprocessors. Judging from the results, the use of a good preprocessor can significantly increase the adaptability of Fortran programs.