Publications

Books

1. Y. Hachisu, A. Yoshida. A Web based System for Error Correction Questions in Programming Exercise (chapter 6). Artificial Intelligence Technologies and the Evolution of Web 3.0 , IGI Global, pp. 124-143 (2015-02)
   [abst]

   In this chapter, we propose a system for generating error correction questions of programs, which are suitable for developing debugging skills in programming education. The system generates HTML files for answering questions and CGI programs for checking answers. They are deployed on a Web server, and learners read and answer questions on Web browsers. It provides an intuitive user interface; a learner can edit codes in place at the text. To make programs including errors for learning debugging, we have analyzed types of errors and defined the processes of error injection as code transformation patterns. If learners can edit any codes freely, it is difficult to check all possible answers. Instead, we have adopted a strategy to restrict editable points and possible answers from the educational view. A demonstration of error correction questions of the C language is available at http://ecq.tebasaki.jp/.

Refereed Journals or Transactions

1. Y. Sawada, Y. Umeda, Y. Hachisu, A. Yoshida, H. Kuwabara. A Method to Localize Defects in Source Codes Using Segments in Programming Exercises (in Japanese). JSSST Computer Software, Vol. 40 No. 4, pp. 4_29-4_36 (2023-12)
   [abst]

   In programming exercises, we propose a method to localize defects based on automatic program repair. Localizing defects is accomplished by comparing a learner's program and model answers using program segments, which are sequences of statements with no branches, and replacing a learner's segments with model answers' segments until all test cases are passed. We implemented a prototype tool for localizing defects and confirmed that our tool can find defects for practical use.
2. Y. Hachisu, N. Azuma, H. Mikami, K. Nagano, A. Yoshida, H. Kuwabara. Prototype of Automatic Error Repair Tool in Control Statements Caused by Grammatical Knowledge of Multiple Programming Languages (in Japanese). JSSST Computer Software, Vol. 39 No. 4, pp. 4_38-4_48 (2022-10)
   [abst]

   We propose a method to automatically correct erroneous control statements written in C, PHP, JavaScript, Python, and Ruby, in case statements are written according to the grammar of another language or mixed grammar of multiple languages. Such kinds of errors are likely to be made when a programmer learns multiple programming languages. In order to support the correction of such errors, we propose a method to analyze a grammatical erroneous code fragment with expression level syntax analysis, and to convert the code through a common model of control statements.
3. Y. Hachisu, A. Yoshida, H. Kuwabara, K. Agusa. A Method for Automatic Input Forms Generation of C Programming Learning Environment on Web (in Japanese). JSSST Computer Software, Vol. 36 No. 4, pp. 4_18-4_24 (2019-10)
   [abst]

   We propose a method for generating input forms on a Web-based C programming learning environment from input function calls in a source program. While Web programming environments have been becoming popular, their input on executing a program is not suited for Web, because it is based on command line input. We have proposed association array model for Web input, instead of stream model. We design new input functions instead of scanf function, which is usually used on learning the C language. Our Web programming environment analyzes a C source program before run, and generates Web forms dynamically. Names of forms are keys and input data are values of an association array. When a form has multiple values, they are treated as a list with iterator functions. We confirmed that we can compile and run sample programs of a textbook using our input functions and Web forms.
4. Y. Hachisu, A. Yoshida, H. Kuwabara, K. Agusa. A Prototype on Proofreader for Learning Programming (in Japanese). JSSST Computer Software, Vol. 35 No. 4, pp. 129-135 (2018-10)
   [abst]

   In programming education, we propose a prototype of program proofreader, which checks whether learners' programs match learning objectives. Learners sometimes tend to think that their tasks are accomplished when their programs produced the same outputs with ones of sample test cases. However, their programs sometimes are not well-written one, that is, they are unsuitable codes for exercises' objectives. To find poorly-written programs, we have implemented a program proofreader which compares learners' programs to a model program written by a teacher from views of learning objectives.
5. Y. Hachisu, S. Kobayashi, A. Yoshida, K. Agusa. Test Case Evaluation System for Programming Exercises (in Japanese). JSSST Computer Software, Vol. 34 No. 4, pp. 54-60 (2017-11)
   [abst]

   In programming exercises, we propose a test case evaluation system which evaluates test cases written by students and gives advices to them in order to make effective test cases by themselves. Teachers define rules to evaluate test cases and advices which is shown to students when their test cases don't satisfy rules. Evaluation rules are described as conditional expressions with data structure of input data. We evaluate our system in writing test cases exercise for a number of students.
6. Y. Hachisu, A. Yoshida, K. Agusa. A Generator for Exercises of Program Error Correction and Answer Checker Programs (in Japanese). IPSJ Transactions on Computers and Education, Vol. 3 No. 1, pp. 64-78 (2017-02)
   [abst]

   We propose a tool that generates exercises of program error correction, which are suitable for developing debugging and code reading skills in programming education, and answer checker programs. We define the processes of error injection as code transformation rules, and analyze types of errors from a view of rewriting operations. If learners can edit only codes which are not correct, it is easy for them to find errors. On the other hand, if they can edit any codes freely, it is difficult for grading programs to check all possible answers. We have analyzed types of errors from a view of how to correct them and adopted a strategy to restrict editable points and possible answers from the educational view. From a correct program, program transformation rules to inject errors, and rules to specify dummy editable points, our tool generates exercises as HTML files and answer checkers as CGI programs. CGI programs check correctness of answers by comparing tokens. Our tool can generate exercises that widely cover the syntax and semantics of the programming language such as loops, arrays, recursive functions, pointers, and structures, and some algorithms such as sorting and searching.
7. A. Yoshida, Y. Hachisu. A Parser for Unpreprocessed Programs without Constraints on Preprocessor Directives (in Japanese). Transactions of Information Processing Society of Japan , Vol. 56 No. 2, pp. 592-610 (2015-02)
   [abst]

   Parsers for unpreprocessed C programs have been proposed, but they have constraints on the po- sitions of preprocessor directives. In this paper, we propose a parser without the constraints while allowing incorrectness of syntax trees. The basic strategy is to ignore directives, and the parser complements tokens virtually to parse syntactical incorrect parts. The parser is implemented based on token-based rewrite rules, and it parses partial codes in programs, such as the insides of macro definitions. As applications, we show two tools: an alignment tool for branch directives and a macro reverse expansion tool. We also show the experiments of analysis of an open source application and discuss the precision and the problems.
8. Y. Hachisu, M. Noro, A. Sawada, H.M. Chang, A. Yoshida. A design and implementation of light-weight fast XQuery processor generator using compiler design (in Japanese). JSSST Computer Software, Vol. 30 No. 4, pp. 67-81 (2013-11)
   [abst]

   We have designed and implemented a generator for an XQuery processor using compiler technique. It generates the processor for a valid XML document in lex, yacc source programs from a DTD file and a query. Because it knows which nodes of a document tree are actually accessed before processing an XML document, it can avoid making nodes which are never accessed. We classify join operations into two types, comparison of equality and numerical order. We use a hash method for the former, and a binary search method for the latter. We demonstrated effectiveness of a compiler-type XQuery processor; it runs faster with less memory than an interpreter-type processor.
9. T. Maebayashi, A. Yoshida, Y. Hachisu, H.M. Chang, M. Noro. A Symbol Table Construction Method for Un-preprocessed Programs (in Japanese). Transactions of Information Processing Society of Japan , Vol. 54 No. 2, pp. 912-921 (2013-02)
   [abst]

   Automatic program transformation is a solution for reducing costs of program development and maintenance. Program analyzers for transformation need to parse un-preprocessed programs for preserving program styles. Because those programs are incomplete in syntax, and lack some definitions of identifiers, the analyzers can not construct a symbol table and the results of analysis become inaccurate. In this paper, we divide obstacles of constructing a symbol table into three types, and then propose a symbol table construction method based on them. We also show that our method contributes accuracy enhancement of a program analyzer by examples.
10. A. Yoshida, Y. Hachisu, A. Sawada, H.M. Chang, M. Noro. A Source Code Rewriting System based on Attributed Token Sequence (in Japanese). Transactions of Information Processing Society of Japan , Vol. 53 No. 7, pp. 1832-1849 (2012-07)
    [abst]

    For automatic replacement of code fragments in a fixed form, we propose “TEBA”: a source code rewriting system based on attributed token sequence. TEBA consists of two subsystems. First one is a pattern-based transformation subsystem which rewrites source code according to a pattern specified as a pair of code fragments. The other one is a parser subsystem which becomes a ba- sis for syntactic analysis of the source code. For parsing source codes, TEBA converts a source code to an attribute token sequence to which the parser sub- system gradually adds syntactic information. After converting a pattern and a target code into token sequences, the transformation subsystem rewrites the to- ken sequence of the target code according to the token sequence of the pattern. We also show an implementation and evaluation of TEBA with examples.
11. Y. Hachisu, A. Yoshida, M. Noro, A. Sawada, H.M. Chang. A method extending CSS based on states of HTML elements (in Japanese). IEICE Transaction on Information and Systems D , Vol. J-94D No. 11, pp. 1931-1934 (2011-11)
    [abst]

    To separate description of behavior and presentation in Web applications, we propose a method extending CSS based on states of HTML elements. It improves maintainability and accessibility of Web applications.
12. A. Sawada, M. Noro, Y. Hachisu, H.M. Chang, A. Yoshida, D. Osa, A. Urano. Design and Evolution of the Software Architecture for Source Code Inspection Tools (in Japanese). JSSST Computer Software, Vol. 28 No. 4, pp. 4_241-4_261 (2011-11)
    [abst]

    In this paper, we discuss the design and evolution of the software architecture for source code inspection tools. Since there are a variety of demands on software quality improvement through source code inspection techniques, a tool for code inspection is required to be flexible enough to keep up with various needs of various users. We have developed JCI (Java Code Inspector): a source code inspection tool for Java, through a three-year-long joint industry-university project which we call OJL (On the Job Learning). In this project, we have designed the software architecture of JCI using the GoF design patterns to realize analyzability, changeability, testability and efficiency. In this paper, we discuss the validity of our software architecture design as a foundation on which we can develop and evolve source code inspection tools, through several types of changes which have been carried out to deal with changing requirements of users.
13. Y. Hachisu, M. Noro, H.M. Chang. An Aspect-Oriented Approach To ORB Middlewares Development (in Japanese). Transactions of Information Processing Society of Japan , Vol. 45 No. 6, pp. 1533-1545 (2004-06)
    [abst]

    The paper describes an aspect-oriented approach to ORB middlewares development. In general, ORB middlewares are modeled as a layered model. We, however, detected crosscutting components in the layered model. To solve the crosscutting problem, we designed and employed an aspect-oriented software architecture for ORB middlewares. The architecture shows language independent design of a framework and a stub-skeleton generator. The generator is conceived as an aspect weaver which yields codes including the framework code. We demonstrated, through the implementation of ORB middleware for XML-RPC, that the architecture contributes to reduce the effort for the implementation and to build flexible and easy-to-modify middlewares.
14. Y. Hachisu, M. Noro, H.M. Chang. Generator for Light-Weight XML Processor with Data Type (in Japanese). JSSST Computer Software, Vol. 19 No. 5, pp. 334-344 (2002-09)
15. Y. Hachisu, S. Yamamoto, K. Agusa. A CASE Tool Platform for an Object Oriented Language. IEICE Transaction on Information and Systems, Vol. E82-D No. 5, pp. 977-984 (1999-05)
    [abst]

    In this paper, we propose a CASE tool platform for Java, called Japid. A CASE tool platform provides various information of source programs and helps CASE tool developers to develop their tools rapidly and easily. Japid has three advanced features: linking fine grained databases dynamically, permitting developers to define their own views, and changing source programs preserving syntactic and semantic constraints. We have made some experiments and developed some CASE tools to show effectiveness of our approach.
16. Y. Hachisu, S. Yamamoto, K. Agusa. OSDG: Object-Oriented System Dependence Graph (in Japanese). Transactions of Information Processing Society of Japan , Vol. 40 No. 4, pp. 1851-1860 (1999-04)
    [abst]

    In this paper, we propose a new control and data dependence graph for an object-oriented language. We call it Object-Oriented System Dependence Graph (OSDG). OSDG shows dependence at fine grained level such as expressions, and enables to analyze composite function and method invocation on an object precisely. We also propose an idea translating a fine grained graph into coarse grained one to decrease amount of data. It allows to show a detail graph of a concerning class and to show rough graphs of other classes. To show effectiveness of OSDG, we define object dependence relation using OSDG.
17. Y. Hachisu, S. Yamamoto, K. Agusa. Some Methods for Specializing Object-oriented Programs. Transactions of Information Processing Society of Japan , Vol. 40 No. 3, pp. 1346-1349 (1999-03)
    [abst]

    In this paper, we propose three approaches to specializing object-oriented programs. The first replaces dynamically dispatched method invocation with statically dispatched method invocation. We describe two techniques for this purpose: the unique name method and rapid type analysis. The second approach consists of class fusion and class reduction, which are techniques for merging closely associated classes into a single class. The last approach is class slimming, which removes unused methods and variables from classes. These approaches resolve the dilemma of whether to write a program elegantly for easy maintenance or tune it up for good performance.
18. Y. Hachisu, S. Yamamoto, T. Hamaguchi, K. Agusa. An Efficient Implementation of Term Rewriting System on a Distributed Memory Architecture. IEICE Transaction on Information and Systems, Vol. E80-D No. 4, pp. 510-517 (1997-04)
    [abst]

    Term Rewriting System (TRS) is a model of computation and it is used in various application such as algebraic specification. TRS has an inherent concurrency and it is suitable for parallel computing. We have already proposed BOB (Bundle Of Branches), which is a mechanism of data management for parallel rewriting. We have proposed a model of parallel rewriting using BOB and implemented a TRS simulator based on this model on a shared memory parallel computer. Because it fully depends on the feature of a shared memory architecture, that is, a process can access any memory element, it is hard to transport it on a distributed memory parallel computer. In this paper, we propose autonomous BOB model. This model is suitable for a distributed memory architecture since a process uses message passing protocol and the method of load balancing is provided. We implement a TRS simulator using this model on a distributed memory architecture and it runs about 30 times faster on 64 processors than on a single processor.

Refereed Symposium or Workshop

1. Y. Hachisu, S. Ozawa, H. Miyajima, A. Yoshida, H. Kuwabara. A Coding Checker for Sequential Conditional Branches (in Japanese). Proc. of JSSST Foundation of Software Engineering 2023 , pp. 55-60 (2023-11)
2. K. Tsukihara, E. Yamamoto, A Nakashima, Y. Hachisu, A. Yoshida, H. Kuwabara. Localize a Fault in a Learner’s Program using Mutation Analysis (in Japanese). IPSJ SSS isn't Summer Symposium 2023 (SSS 2023) , pp. 117-124 (2023-08)
3. Y. Sawada, Y. Umeda, Y. Hachisu, A. Yoshida, H. Kuwabara. An Automatic Feedback Method for a Learner’s Editing Source Codes in Programming Exercises (in Japanese). Proc. of JSSST Foundation of Software Engineering 2022 , pp. 55-60 (2022-11)
   [abst]

   In programming exercises, we propose a method to localize defects based on automatic program repair. Localizing defects is accomplished by comparing a learner's programs and model answers using program segments, which are sequences of statements with no branches, and replacing a learner's segments with model answers' segments until pass testcases. We implemented a localizing defects tool and confirmed that our tool can find defects for practical use.
4. Y. Hachisu, N. Azuma, H. Mikami, K. Nagano, A. Yoshida, H. Kuwabara. Automatical Error Repair in Control Statements Caused by Grammatical Knowledge of Multiple Programming Languages (in Japanese). Proc. of JSSST Foundation of Software Engineering 2021 , pp. 51-60 (2021-11)
   [abst]

   We propose a method to automatically correct erroneous control statements written in another programming language. The error here is, for example, to write control statements in C, PHP, JavaScript, etc. in Python code. This is an error that is likely to occur when a programmer learns multiple programming languages. In order to support the correction of such errors, we propose a method to analyze erroneous control statements by defining a common model of control statements and converting the code through the model.
5. T. Koyama, Y. Hachisu, A. Yoshida, H. Kuwabara. Programming Learning Materials using a Micro Mouse Simulator (in Japanese). IPSJ SSS isn't Summer Symposium 2020 (SSS 2020) , pp. 54-61 (2020-12)
   [abst]

   We proposes a learning material using a Micro Mouse Simulator to promote motivation and to learn a practical programming language. We have implemented learning programming environment as a Web site. Learner mouse in our simulator by JavaScript programs. The size of the maze and the position of the goal in the simulator can be changed according to the learning contents. The simulator is designed to teach basic concepts of procedural language such as sequential, branch, repetition, array, and search algorithms such as the left-hand rule through solving mazes.
6. Y. Hachisu, S. Ishimoto, A. Yoshida, H. Kuwabara. A matching method of variables in editing source codes by programming learners with ones in a model answer (in Japanese). Proc. of JSSST Foundation of Software Engineering 2020 , pp. 109-114 (2020-11)
   [abst]

   We propose a matching method of variables in editing source codes by programming learners with ones in a model answer. We classify features of variables into six types, and define coarse patterns and fine patterns for abstract syntax trees to match variables.
7. Y. Hachisu, A. Morimoto, S. Matsuo, C. Kato, A. Yoshida, H. Kuwabara. A learning support tool for understanding function calls with pointer parameters (in Japanese). Proc. of JSSST Foundation of Software Engineering 2019 , pp. 103-108 (2019-11)
8. Y. Adachi, Y. Hachisu, A. Yoshida, H. Kuwabara, K. Agusa. A Support System for Understanding the Syntax of Programming Language based on a Syntax Diagram (in Japanese). IPSJ Summer Symposium in front of Shiranui-sea 2018 (SSS 2018) , 8 pages (2018-08)
   [abst]

   We propose a syntax diagram instance, which shows the corresponding program fragments in non-terminal nodes of a syntax diagram, in order to help learners to understand the syntax of a programming language. We have implemented a tool showing syntax diagrams and syntax diagram instances. The tool helps learners to understand the syntax errors and the reasons for the unexpected execution results of their own programs. We have evaluated our approach by using the tool in a programming exercise of a student group.
9. S. Ishimoto, Y. Hachisu, A. Yoshida, H. Kuwabara, K. Agusa. Assessing Coding Situations on a Programming Exercise from Views of Syntax Element Types (in Japanese). IPSJ Summer Symposium in front of Shiranui-sea 2018 (SSS 2018) , 8 pages (2018-08)
   [abst]

   We propose a way of assessing learners' coding situations on programming exercise by analyzing their editing source codes. We can understand their codes roughly by extracting branches and loops and finely by extracting operators and types of variables on assignments. We have confirmed that we can find errors of students' editing codes through programming exercises of eleven students.
10. Y. Hachisu, A. Yoshida, H. Kuwabara, K. Agusa. A Prototype of Proofreader for Programming Exercises (in Japanese). Proc. of JSSST Foundation of Software Engineering 2017 , pp. 53-62 (2017-11)
    [abst]

    For the discipline of writing well programs in exercises, we propose a prototype of program proofreader, which checks learners' programs against learning objectives. In programming exercises, learners sometimes tend to think that their tasks were accomplished when their programs were executed in the same ways as sample test cases. However, their programs sometimes are not well-writtern one, that is, they lack simplicity, clarity, and generality, and are unsuitable codes for exercises' objectives. To find poorly-written programs, we have implemented a program proofreader which compares learners' programs to a model program written by a teacher from views of learning objectives.
11. S. Kobayashi, Y. Hachisu, A. Yoshida, K. Agusa. Test Case Evaluation System with User Defined Data Structure and Functions for Programming Learners (in Japanese). Proc. of JSSST Foundation of Software Engineering 2016 , pp. 33-42 (2016-12)
12. A. Yoshida, Y. Hachisu, K. Agusa. A Prototype of PHP Online Partial Evaluator for Web Application Development (in Japanese). Proc. of JSSST Foundation of Software Engineering 2016 , pp. 217-222 (2016-12)
13. Y. Hachisu, A. Yoshida, K. Agusa. A Support Tool for Beginners of Programming to Understand Imperative Program's Behaviour (in Japanese). Proc. of JSSST Foundation of Software Engineering 2015 , pp. 97-102 (2015-11)
14. Y. Hachisu, A. Yoshida, K. Agusa. An Evaluation System of Test Cases on WebIDE-based Programming Exercises (in Japanese). Proc. of JSSST Foundation of Software Engineering 2014 , pp. 241-250 (2014-12)
15. A. Yoshida, Y. Hachisu. A Pattern Search Method for Unpreprocessed C Programs Based on Tokenized Syntax Trees. Proc. of 14th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM2014) , pp. 295-304 (2014-09)
    [abst]

    Pattern search of programs is a fundamental func- tion for supporting programming. In this paper, we propose a search method for unpreprocessed programs, which are difficult to parse. Our parser directly parses them by rewriting token sequences, and allows minor errors in syntax trees. The search tool takes queries that are the same as the format of program fragments. By using the same parser for both queries and target programs, programmers have no need to describe the detail structures of syntax trees in queries. To support accurate search, we also show an alignment tool for branch directives, which converts undisciplined directives to discipline ones, and a reverse macro expansion tool, which integrates the use of macro calls. Finally, we present some experiments in which we have applied the tools to an open source application, and discuss how to improve our tools.
16. Y. Hachisu, A. Yoshida. A Support System for Error Correction Questions in Programming Education. Proc. of International Conference on e-Learning 2014 (EL2014) , International Association for Development of the Information Society (IADIS), pp. 249-258 (2014-07)
    [abst]

    For supporting the education of debugging skills, we propose a system for generating error correction questions of programs and checking the correctness. The system generates HTML files for answering questions and CGI programs for checking answers. Learners read and answer questions on Web browsers. For management of error injection, we have analyzed types of errors and defined the processes of error injection as code transformation patterns. The system synthesizes code fragments including errors by transforming correct code fragments according to the selected patterns. Full coverage of all possible answers is difficult. Instead, we have adopted a strategy to restrict editable points and possible answers from the educational view. To confirm the effectiveness of the system, we have generated questions using several examples and applied them to a programming exercise as an evaluation experiment.
17. Y. Hachisu, A. Yoshida. Generation of Error Correction Questions for Beginners of Programmming (in Japanese). Proc. of JSSST Foundation of Software Engineering 2013 , pp. 35-40 (2013-11)
18. Y. Hachisu, A. Yoshida, H.M. Chang, M. Noro. Rewriting HTML4 to HTML5 using Contexts (in Japanese). Proc. of JSSST Foundation of Software Engineering 2012 , pp. 21-26 (2012-12)
19. T. Maebayashi, A. Yoshida, Y. Hachisu, H.M. Chang, M. Noro. A Symbol Table Construction Method for Un-preprocessed Programs (in Japanese). Proc. of Software Engineering Symposium 2012, pp. 1-6 (2012-08)
    [abst]

    Automatic program transformation is a solution for reducing costs of program development and maintenance. Program analyzers for transformation need to parse un-preprocessed programs for preserving program styles. Because those programs are incomplete in syntax, and lack some definitions of identifiers, the analyzers could not construct a symbol table and the results of analysis become inaccurate. In this paper, we divide obstacles of constructing a symbol table into three types, and then propose a symbol table construction method based on them. We also show that our method contributes accuracy enhancement of a program analyzer by examples.
20. K. Tatemichi, A. Yoshida, Y. Hachisu, H.M. Chang, M. Noro. A Conversion Method of Program Fragments into a DOM Tree as Syntax Tree (in Japanese). Proc. of Software Engineering Symposium 2012, pp. 1-6 (2012-08)
    [abst]

    There are many web pages including program descriptions, such as repository sites and learning sites for programming, and they contribute software development and programming education. These pages, however, are sometimes difficult to read for readers, because they are designed from author’s views. In this paper, we show a conversion method of program descriptions to sub-trees as parts of the DOM tree. After invoking the conversion method at client side using bookmarklet, we can change program descriptions to our favorite style and layout and add high-level capabilities by modifying the DOM tree. Our method consist of two techniques, detection of program fragments in web pages and construction of the syntax tree of a program fragment including HTML tags. We also show an experiment for evaluating accuracy of our method.
21. Y. Hachisu, M. Noro, A. Sawada, H.M. Chang, A. Yoshida. An XQuery processor generator using compiler design (in Japanese). Proc. of JSSST Foundation of Software Engineering 2012 , pp. 21-20 (2011-11)
22. H. Soga, A. Yoshida, Y. Hachisu, H.M. Chang, M. Noro. A Macro Reduction Method Supporting Multiple Program Representations (in Japanese). Proc. of Software Engineering Symposium 2011, pp. 1-6 (2011-09)
    [abst]

    Duplicated code fragments in a source code cause to decrease the readability and the maintainability. The purpose of this paper is removal of duplicated code fragments using macro reduction. We propose a method for macro reduction supporting multiple program representations.
23. Y. Hachisu, M. Noro, A. Sawada. Efficient XQuery Processor using Lazy Parsing (in Japanese). Proc. of Software Engineering Symposium 2008, pp. 119-122 (2008-08)
    [abst]

    In this paper, we propose a light-weight and high-performance XQuery processor based on lazy parsing. A lazy parser creates a XML tree whose nodes are actually accessed by an application. We implemented an XQuery processor based on our method and compared the processor with SAXON. In the best case, our processor is 50\% faster than SAXON with 2/3 memory usage. Our processor, however, runs slower in processing nested FOR-loops. We find the reason and propose a method to overcome the drawback.
24. Y. Hachisu, M. Noro, H. Miyata, T. Ushida. Efficient XQuery Processing using Stream-Oriented Approach (in Japanese). Proc. of Software Engineering Symposium 2007, pp. 69-78 (2007-08)
    [abst]

    In this paper, we propose a light-weight and high-performance stream-oriented XQuery processing method to process a query with its path that has predicates in the middle position. Existing stream-oriented XQuery processors based on push-down automaton are not able to process such a query. In order to overcome the drawback, we use a list for saving information in addition to push-down automaton. We implemented an XQuery processor based on our method and compared the processor with SAXON. Our processor is faster than SAXON and uses less amount of memory. In the best case, the processor we designed and implemented runs in the double speed with 1/560 memory usage.
25. Y. Hachisu. Towards XML Concurrent Parsing. IADIS Virtual Multi Conference on Computer Science and Information Systems (MCCSIS2005) , International Association for Development of the Information Society (IADIS), 5 pages (2005-04)
    [abst]

    We propose an idea of a concurrent XML parser, which constructs the whole document tree concurrently on the multi-threading environment like Java. We decompose the process of parsing into two phases, preprocessing and materializing, which are performed concurrently. The preprocessor reads a XML document and saves its structure as the internal structure. A materializer creates nodes of the tree according to the data in the internal structure. We formalize a model for concurrent XML parsing as a kind of the producer/consumer model: the preprocessor is the producer, a materializer is a consumer, and the internal structure is the shared buffer. We implemented a concurrent XML parser and estimated its performance by simulations.
26. Y. Hachisu. Visitor Class Generator for DOM Tree with Namespaces (in Japanese). Proc. of JSSST Foundation of Software Engineering 2003 , pp. 161-164 (2003-11)
27. Y. Hachisu. Management of HTML Documents based on XML (in Japanese). Proc. of JSSST Foundation of Software Engineering 2002 , pp. 167-170 (2002-11)
28. Y. Hachisu. Management of Linear Structured HTML Files using XML (in Japanese). Proc. of JSSST Foundation of Software Engineering 2001 , pp. 175-178 (2001-11)
29. Y. Hachisu. Exchanging Formats of Software Specification (in Japanese). Proc. of 14th IEICE Data Engineering Workshop, 4 pages (2001-03)
30. Y. Hachisu, S. Yamamoto, K. Agusa. Japid: A CASE Tool Platform for Java (in Japanese). Proc. of IPSJ Object-Oriented Symposium '99, pp. 21-28 (1999-07)
31. Y. Hachisu, S. Yamamoto, T. Hamaguchi, K. Agusa. A fine grain source repository for Java (in Japanese). IPSJ Computer System Symposium '96, pp. 147-154 (1996-11)

Other Presentations

1. T. Toya, M. Ogawa, Y. Hachisu, A. Yoshida, H. Kuwabara. Automatic Programming Exercise Generation from A Model Answer Program (in Japanese). FIT2023, pp. 315-320 (2023-09)
2. R. Matsui, Y. Hachisu, A. Yoshida, H. Kuwabara. Research and Discussions for Providing Support for Variable Names (in Japanese). 39th Conference Proceedings JSSST, 9 pages (2022-09)
3. H. Horie, E. Souhama, Y. Hachisu, A. Yoshida, H. Kuwabara. Data Pre-processing Examinations in Web Page Screenshot Classification Using Machine Learning (in Japanese). 39th Conference Proceedings JSSST, 6 pages (2022-09)
4. R. Matsui, K. Watanabe, Y. Hachisu, A. Yoshida, H. Kuwabara. Support for Proofreading Papers Based on Machine Learning Using Change Histories (in Japanese). FIT2021, pp. 335-342 (2021-08)
5. S. Kubota, Y. Hachisu, A. Yoshida, H. Kuwabara. A Method for Grasping Coding Status to Assist Students in Programming Exercise (in Japanese). IPSJ SIG Notes 2019-CE-151, 8 pages (2019-10)
   [abst]

   In programming exercise at university, it is difficult for a small number of instructors to grasp how well each student have coded because there are many students and the exercise time is limited. In this research, we define degree of progress, which shows how much a student makes progress compared to a model answer. We also define degree of activity, which shows how many characters in source code are changed per unit time. We propose a way to identify students who need the support of instructors by expressing the situation of them in two dimension graph, whose horizontal axis is degree of progress, and the vertical axis is degree of activity.
6. Y. Hachisu, A. Yoshida, K. Agusa. A Prototype of Program Proofreader using Learning Objectives (in Japanese). 33th Conference Proceedings JSSST, 6 pages (2016-09)
   [abst]

   We propose a prototype of program proofreader, which checks learners' programs against learning objectives. In programming exercises, learners sometimes tend to think that their tasks were accomplished when their programs were executed in the same ways as sample test cases. However, their programs sometimes include redundant computation and unsuitable codes for exercises' objectives. We have implemented a program proofreader which compares learners' programs to a model program written by a teacher from views of learning objectives.
7. Y. Hachisu, K. Agusa. A Simulator of Domestic Power Distribution with Power Packets (in Japanese). IEICE General Conference 2016, 1 pages (2016-03)
8. D. kato, Y. Hachisu, A. Yoshida, K. Agusa. A Code Review Method with Def-use Graph of Single Variable (in Japanese). IEICE Technical Report SS2014-73, Vol. 114 No. 510, 6 pages (2015-03)
9. Y. Hachisu, A. Yoshida, K. Agusa. Automatic Generation of Error Correction Questions for Learning Programming (in Japanese). IPSJ SIG Notes 2004-CE-125, 8 pages (2014-05)
   [abst]

   In programming exercises at universities, lecturers can give learners good advice by understanding learners' coding processes. It is, however, difficult to understand all learners' processes during the limited exercise course hours. In this paper, we propose a way for understanding coding processes by comparing learners' codes and correct programs prepared by lecturers from the views of operators, expressions, statements, and structures of statements. We have implemented a Web integrated development environment to collect learners' editing codes. We have applied our approach to some exercises and confirmed its effectiveness.
10. Y. Hachisu, A. Yoshida. Automatic Generation of Error Correction Questions for Learning Programming (in Japanese). IEICE Technical Report SS2012-70, Vol. 112 No. 458, pp. 63-68 (2013-03)
    [abst]

    We propose a method for automatic generation of error correction questions for learning programming. Error correction questions are suitable for improving skills of code reading and debugging. But they are not known how to make questions and how to decide correct answers or not. In this paper, we classify common programming errors and describe them as rewriting patterns. We propose a method for generating programs including these errors as questions.
11. Y. Hachisu. Macro Functions based on XML (in Japanese). 18th Conference Proceedings JSSST, 4 pages (2001-09)
12. Y. Hachisu. Workbench for Formal Specification (in Japanese). IPSJ SIG Notes 2000-SE-125, pp. 99-104 (2000-01)
13. Y. Hachisu, S. Yamamoto, K. Agusa. A CASE Tool Platform and Specializing Object Oriented Programs. International Workshop on the Principles of Software Evolution , pp. 58-62 (1998-04)
14. Y. Hachisu, S. Yamamoto, K. Agusa. Specialization for Componentware (in Japanese). Proc. of IPSJ Winter Workshop in Ena, pp. 23-24 (1998-01)
15. Y. Hachisu, S. Yamamoto, T. Hamaguchi, K. Agusa. An Implementation of Term Rewriting System on a Distributed Memory Architecture. Proc. of the Fourth International Parallel Computing Workshop , pp. 159-168 (1995-09)
16. Y. Hachisu, S. Yamamoto, K. Agusa. An Implementation of Distributed TRS on Autonomous BOB Model (in Japanese). TR of IEICE CPSY94-35, pp. 65-72 (1994-07)