Jae-Won Oh

The effects and safety of dexibuprofen compared with ibuprofen in febrile children caused by upper respiratory tract infection

AIM To evaluate the antipyretic efficacy and tolerability of dexibuprofen compared with ibuprofen in children with fever caused by upper respiratory tract infection (URTI). METHODS The study population consisted of children aged 6 months to 14 years. At the time of visit to the hospital, the children had fever; the cause of fever was determined to be URTI by a paediatrician based on history taking and physical examination. The study was a multicentre, randomized, double-blind, controlled parallel group, comparative, Phase 3 clinical trial, conducted at three hospitals. By using a computer-based random assignment program, the subjects were allocated to the following three groups: 5 mg kg(-1) dexibuprofen group, 7 mg kg(-1) dexibuprofen group, and 10 mg kg(-1) ibuprofen group. RESULTS In the clinical trial of the antipyretic action of dexibuprofen in patients with fever caused by URTI, there was no statistically significant difference in maximal decrease of temperature and mean time to become apyrexial among the 5 mg kg(-1) dexibuprofen, 7 mg kg(-1) dexibuprofen and 10 mg kg(-1) ibuprofen groups (P > 0.05). There also was no significant difference in adverse drug reaction (P > 0.05). CONCLUSIONS Dexibuprofen is as effective and tolerable as ibuprofen. A dose of 5 mg kg(-1) and 7 mg kg(-1) dexibuprofen in place of 10 mg kg(-1) ibuprofen would be sufficient to control fever caused by URTI in children.

Patterns for configuration requirements of Software-as-a-Service

Software-as-a-Service is becoming popular in the software business, due to its rapid delivery and cost effectiveness in development and maintenance. Software-as-a-Service should be provided in single code base and operated as a single instance. To meet these constraints and requirements from various customers, Software-as-a-Service must be highly configurable. To develop configurable Software-as-a-Service, it is important to elicit and analyze configuration requirements in the early stages of development. Another issue is that on implementing configuration requirements, there are duplicated and untidy code segments. In our study, configuration requirements are identified and classified. This study introduces design patterns to remove duplicated codes for configuration.

Automated Transformation of Template-Based Web Applications into Single-Page Applications

In a template-based web application (TWA), a template is used as a common structure or layout to dynamically generate web pages. The consistent structure helps users easily obtain information. However, TWAs still have an interaction problem: whenever a user clicks a hyperlink or submits a form, a new page is loaded. Therefore, we need to reduce communication between a browser and a server by avoiding loading the same template twice. This paper proposes a technique of transforming a Java-based TWA into a single-page application (SPA) with partial page refreshes. An Eclipse plugin is also presented for automatic reengineering of TWAs. Our technique is applied to typical TWAs and discussed with respect to quality attributes such as performance, bookmarkability, and backward navigation.

Co-Writing Multiple Files Based on Directory Locality for High Performance of Small File Writes

Fast File System(FFS) utilizes large disk bandwidth to improve the write performance of large files. One way to improve the performance is to write multiple blocks of a large file at a single disk I/O through the disk bandwidth. However, rather than disk bandwidth, the performance of small file writes is limited by disk access times significantly impacted by disk movements such as disk seek and rotation because FFS writes each of small files at a single disk write. We propose CW-FFS (Co-Writing Fast File System) to improve the write performance of small files by minimizing the disk movements that are needed to write small files to disks. Its key technique called co-writing scheme is to dynamically collect multiple small files named by a given directory and then write them at a single disk I/O to contiguous disk locations. Co-writing several small files at a single disk I/O reduces multiple disk movements that are needed for small file writes to one single disk movement, thus increasing the overall write performance of write-intensive applications. Furthermore, a file allocation scheme is introduced to prevent co-writing scheme from having a negative impact on disk spatial locality of small files named by a given directory. The measurement of our technique implemented in the OpenBSD 4.0 shows that CW-FFS increases the performance of small file writes over FFS in the range from 5 to 35% in the Postmark benchmark.

MVC architecture driven restructuring to achieve client-side web page composition

This paper presents a restructuring approach to relocating web page composition from servers to browsers for Java web applications. The objective is to reduce redundant manipulation and transfer of code/data that are shared by web pages. The reduction is carried out through a restructuring algorithm, effectively keeping consistency between source and target applications from the perspective of the model-view-controller (MVC) architecture, because the problem requires the target application to preserve the observable behavior of its source application. Case studies show that our restructuring tool can efficiently support the restructuring process.

A multiple-file write scheme for improving write performance of small files in Fast File System

Fast File System (FFS) stores files to disk in separate disk writes, each of which incurs a disk positioning (seek + rotation) limiting the write performance for small files. We propose a new scheme called co-writing to accelerate small file writes in FFS without sacrificing its advantages. The scheme collects writes to small files in the same directory and stores them together to disk in a single large disk write. Co-writing multiple files in one disk I/O can reduce disk positioning times resulting from small file writes in FFS. Our experiments on OpenBSD show that the co-writing slashes the cost of small file writes in FFS by up to 33%, in both real-world and synthetic benchmarks.