AY 2026 Undergraduate School Course Catalog AY 2026 Undergraduate School Course Catalog AY 2026 Undergraduate School Course Catalog
| 2026/02/19 |
| Open Competency Codes Table Back |
| 開講学期 ／Semester |
2026年度／Academic Year 2学期 ／Second Quarter |
|---|---|
| 対象学年 ／Course for; |
1st year |
| 単位数 ／Credits |
4.0 |
| 責任者 ／Coordinator |
HISADA Yasuhiro |
| 担当教員名 ／Instructor |
HISADA Yasuhiro, DEMURA Hirohide, HIRATA Naru, NAKASATO Naohito, KITAZATO Kohei, SAMPE Takeaki, OFUJI Kenta, PYSHKIN Evgeny, YAMADA Ryuhei, ZHOU Yinghui |
| 推奨トラック ／Recommended track |
－ |
| 先修科目 ／Essential courses |
－ |
| 更新日／Last updated on | 2026/02/06 |
|---|---|
| 授業の概要 ／Course outline |
(ICTG class starts in Q4.And Prof. Pyshkin, E. is in charge of the class.) [C1-C6 Class:Q2] As for the programming by C language, there are a lot of students who do not have an enough skill, though it is very important for the student of University of Aizu. This course is the first half of the 2-quarter C course (latter half is called "Programming C"), and taught basics of C programming language. [ICTG Class:Q4] This course presents foundation concepts of programming such as numeral systems, syntax and semantics, essentials of software code organization, concept of data type, algorithms, basic control structures, functions, modularity, arrays, strings, simple structural types, and introduction to incremental design. The special track is organized as a series of connected activities including lectures, hands-on sessions, testing sessions, workshops, and individual project exercises using C programming language and focusing on discussing structural programming concepts and functional organization of software code. |
| 授業の目的と到達目標 ／Objectives and attainment goals |
[C1-C6 Class] Corresponding Learning Outcomes: ・Graduates are aware of their professional and ethical responsibilities as an engineer, and are able to analyze societal requirements, and set, solve, and evaluate technical problems using information science technologies in society. ・Graduates are able to apply their professional knowledge of mathematics, natural science, and information technology, as well as the scientific thinking skills such as logical thinking and objective judgment developed through the acquisition of said knowledge, towards problem solving. This course is aimed to learn skills such as: ・The concept of the programming is understood. →When the problem is given, a series of operation until the program to solve it is made is acquired. ・The fundamental syntax of C languages (i.e. branch, loop, array, and function, etc.) are understood. →You can make a program using them. ・A good programming style is acquired. [ICTG Class] After course completion the students will have the following learning outcomes: - Understanding foundation concepts of information and information processing in computer systems: information, data representation, coding systems; - Understanding of an algorithm and its definition; - Understanding of a programming language syntax and its definition; - Knowledge of basic principles of imperative and structured programming; - Ability to write simple programs in C language by using basic control structures (conditional statements, loops, switches, branching, etc.); - Ability to create a programmable model for a problem given; - Understanding of a function concept; - Ability to use pointers and pointer arithmetic in the simple cases; - Basic knowledge of working with arrays in C language; - Basic knowledge of using structures and user-defined types; - Understanding a defensive programming concept; - Ability to handle possible errors during program execution; - Elementary knowledge of programming code style and organization. |
| 授業スケジュール ／Class schedule |
[C1-C6 Class:Course Contents and Methods] The first two periods will be devoted to lectures, and the remaining two periods will be devoted to computer exercises. Lecture 1 What is a computer? Lecture 2 Variable, input/output and operator Lecture 3 Various variable types and type conversion Lecture 4 Conditional execution(branch) -if and switch/case- Lecture 5 Loop1 - while -. Lecture 6 Loop2 - for- Lecture 7 One-dimensional array Lecture 8 Flow chart Lecture 9 Two-dimensional array(Matrix) Lecture 10 The review and the application of matrix. Lecture 11 The function1 Basics Lecture 12 The function 2 Application Lecture 13 The function 3 Further topics on function Lecture 14 Overall review and a good programming [C1-C6 Class:Preparation and Review] Students are expected to review the lecture materials in advance for each class. At the same time, it is recommended that they work on Exercise A (basic exercises). In addition, any assignments not completed during class time should be finished by the submission deadline. The estimated time for preparation and review is 7-9 hours per session. [ICTG class:Course Contents and Methods] Along with traditional activities (lectures and exercises) the course involves the learning methods including hands-on sessions, testing sessions, code review sessions, as well as workshops. We use the content-based approach for course structuring rather than time-based approach. Approximate coverage of topical units by class days is provided. Unit 1. Introduction and Foundation Concepts (Days 1-2) Unit 2. Data Type Concept. Integer Types (Day 2-3) Unit 3. Elementary Introduction to C Program Organization (Day 4) Unit 4. Basic Control Structures (Days 4-5) Unit 5. Floating-point computations (Day 6) Unit 6. C Language Data Types and Control Structures Revisited (Day 7) Unit 7. Functions (Days 8-9) Unit 8. Pointers, Arrays, Strings (Days 10-11) Unit 9. Introducing Structures (Days 12-13) Unit 10. Course Summary (Day 14) [ICTG class:Pre-class and Post-class Learning] Before each class, the students are encouraged to study the lecture materials and the relevant demonstration examples provided (typically 1 hour per session). After-class activities usually include quizzes on lecture materials (preparation/quiz time typically 1 hour per session), completing hands-on activities (1.5 hours per class day), and working on individual exercises (typically 6 hours per session1. In total, preparation/review time is 7-9 hours per class day. |
| 教科書 ／Textbook(s) |
[C1-C6 Class] ・Handouts (Sold in the University book shop). [ICTG Class] ・Necessary materials are distributed via LMS. |
| 成績評価の方法・基準 ／Grading method/criteria |
[C1-C6 Class] ・Quizzes 10% ・Programming exercise 30% ・Mid-term exam 10% ・Final exam 50% (*) In principle, a score of at least 35% is required on the final exam to pass the course. [ICTG Class] In 100-point scale: ・Regular quizzes give up to 20 points; ・Exercises, individual projects, hands-on sessions - up to 30 points; ・Testing sessions, workshops - up to 20 points; ・Final quiz - up to 30 points. Bonus points can be given to the students for active participation in the classwork, for highly creative and high-quality exercise solutions, interesting questions, etc., to cover the deficit of the whole course score up to 20 points in 100-point scale. The students with high level of performance (more than 75% of max score for both regular quizzes and practical activities) are relaxed from the final quiz, thus, getting the maximum points for the latter activity. The final course scores are calculated based on all above-mentioned regular activities including the final quiz. There is no exam in this group. |
| 履修上の留意点 ／Note for course registration |
[C1-C6 Class] Attendance of 2/3 or more is required for each lecture and exercise. Moreover students must take midterm and final exams. [ICTG Class] Students are expected to have elementary knowledge of mathematical and algorithmic logics and to be able to learn how to understand the programming code. Some primary understanding of computer organization basics is desirable. The course teaching language is English; thus, students have to have good communication, reading and apprehension skills in English. This course provides a foundation for the course PL02 "C Programming" |
| 参考(授業ホームページ、図書など) ／Reference (course website, literature, etc.) |
[C1-C6 Class] reference book: "Programming in C --1st step -- " 3rd edition, Uchida, Ohmsha Ltd. Course web page: file:///home/course/prog0/public_html/2026/welcome.html (inside university) http://www.u-aizu.ac.jp/course/prog0/ (outside university: subset-version) [ICTG Class] The course instructor Dr. Evgeny Pyshkin has working experiences in software design, development, QA and tech writing. He worked as a software engineer for St. Petersburg Polytechnic University and participated in software projects with Spectrasize (Switzerland) as a developer, tech writer and project manager. You may find more information on https://u-aizu.ac.jp/~pyshe/. |
| Open Competency Codes Table Back |
| 開講学期 ／Semester |
2026年度／Academic Year 3学期 ／Third Quarter |
|---|---|
| 対象学年 ／Course for; |
1st year |
| 単位数 ／Credits |
4.0 |
| 責任者 ／Coordinator |
HIRATA Naru |
| 担当教員名 ／Instructor |
SAMPE Takeaki, HISADA Yasuhiro, SHIN Jungpil, PYSHKIN Evgeny, HIRATA Naru, Idnin Pasya Bin Ibrahim, SEMBA Shogo, THENUWARA HANNADIGE Akila Sanjaya.S, YAMAMOTO Keiko |
| 推奨トラック ／Recommended track |
－ |
| 先修科目 ／Essential courses |
Courses preferred to be learned prior to this course (This course assumes understanding of entire or partial content of the following courses) - PL01 "Introduction to Programming" |
| 更新日／Last updated on | 2026/02/06 |
|---|---|
| 授業の概要 ／Course outline |
(ICTG class starts in Q1. Prof. Pyshkin, E. is in charge of the class.) (Both C1-C6 classes and ICTG class) This course follows the PL01 "Introduction to Programming" course and teaches programming using the C language. The course is organized based on the following concept. - Subsequent courses, such as "algorithms and data structures", and Graduation Thesis research require fairly high programming skills. Students can acquire skills to match that. - Students will be given an introduction to algorithms, to build bridges to subsequent classes. - Learn programming skills to develop larger programs. (ICTG class) This course is aimed at advancing the concepts of programming and software code organization within the framework of structural and procedural programming paradigms. The major objective is to provide students with understanding of code organization and functional hierarchical decomposition with using complex connected data types developed on C in practical situations. The special track is organized as a series of connected activities including lectures, hands-on sessions, testing sessions, workshops, and individual project exercises using C programming language and focusing on discussing structural programming concepts and functional organization of software code. |
| 授業の目的と到達目標 ／Objectives and attainment goals |
Corresponding Learning Outcomes: (A) Graduates are aware of their professional and ethical responsibilities as an engineer, and are able to analyze societal requirements, and set, solve, and evaluate technical problems using information science technologies in society. (B) Graduates are able to apply their professional knowledge of mathematics, natural science, and information technology, as well as the scientific thinking skills such as logical thinking and objective judgment developed through the acquisition of said knowledge, towards problem solving. [Competency codes] C-SD-003, C-SD-006 (ICTG class) After course completion the students will have the following learning outcomes: - Understanding a functional hierarchical code organization; - Ability to work with textual information, characters and strings; - Ability to create a hierarchy of structural types and arrays; - Understanding a concept of object thinking within the framework of functional model. - Understanding a concept of functional hierarchical code organization. - Knowledge of major Standard C library features; - Understanding how to create practical C-based models for specific subject domains. |
| 授業スケジュール ／Class schedule |
[Course Contents and Methods] Along with traditional activities (lectures and exercises) the course involves the learning methods including hands-on sessions, testing sessions, code review sessions, as well as workshops. We use the content-based approach for course structuring rather than time-based approach. Approximate coverage of topical units by class days is provided (ICTG class) Since the course assumes more activities rather than lectures and exercises, we use the content-based approach for course structuring rather than time-based approach. Approximate coverage of topical units by class days is provided. Unit 1. Revisiting the Lessons Learned in PL01 (Day 1) Introduction to the course. Brief summary of the concepts and models presented in the course PL01 "Introduction to Programming". Programming vs. software development revisited. Major stages of software production. Comment to learning process organization: "orthogonality" of lectures/hands-on/exercise tracks. Introduction to code refactoring (link to the final course exercise in Q1). Unit 2. Useful C Features Not Covered Before (Days 1-2) Using and defining macros. Language features to avoid unsafe macros. Unions. Bit fields. Standard library essentials. Importance to use standard library functionality. Dynamic arrays. Binary vs. text Files. Input/output revisited. Working with text and binary files. Unit 3. Object Thinking (Days 3-4) Advance introduction to object thinking. "Object-oriented" programming with C. Project organization based on structural types, array of structural objects and functional hierarchy. From subject domain to data models. Unit 4. Advanced Use of Complex Types (Days 4-5) Arrays of structural objects. Dynamic memory allocation. Advanced introduction to scope and memory classes. Functions dealing with complex types. C program organization revisited: attention to focus on data types. Unit 5. Generic Algorithms in C (Day 6) Problem of sorting. How to develop a type-invariant implementation. Pointers to functions. Callback functions. Unit 6. Concept of Standard C (Days 7-8) Standard C features. Execution control and memory allocation features; Math functions; Character processing; String processing; Boolean type; Input/output features; Quick sort; Date/time processing. Randomization; Locales. Unit 7. Multidimensional Arrays, Integration with Existing Source Code (Days 9-10) How to define and use a multidimensional array. Programming for application areas: IR tasks as an (vector space model); modeling music (integration of student's algorithms with the existing larger-scale source code). Unit 8. Introduction to Algorithms and Data Structures (Days 11-12) Algorithmic complexity. Sets of objects. Sorting. A concept of code reuse. Recursive processes. Processing big data arrays. Linked structures. Unit 9. Introduction to Lexical and Syntactical Analysis (Days 13-14) Programming simple lexical analyzers and parsers. Finite state machines and their program models. Unit 10. Course Summary (Day 14) Revisiting the core topics. Materials for self-study. Final discussion. Final quiz. (C1-C6 classes) - Review of Intro. Programming course. - Characters, storage classes - File input & output - Address and pointers, - Pointer arithmetic, pointers and arrays - Manipulation of character strings - Function call by value, pointers as arguments - Command line options - Dynamic memory allocation - Structures and members - Pointers to structures, structure nesting - Manipulation of a linked list. - Recursive call of functions - Preprocessor, group programming and conditional compilation - The good programming style Detailed schedule of lectures will be shown in the course web pages. [Pre-class and Post-class Learning] Before each class, the students are encouraged to study the lecture materials and the relevant demonstration examples provided (typically 1 hour per session). After-class activities usually include quizzes on lecture materials (preparation/quiz time typically 1 hour per session), completing hands-on activities (1.5 hours per class day), and working on individual exercises (typically 6 hours per session1. In total, preparation/review time is 7-9 hours per class day. |
| 教科書 ／Textbook(s) |
(ICTG class) Necessary materials are distributed via LMS. (C1-C6 classes) Handouts (To be available at the University shop at the beginning of Q2). PL01 Intro. programming and PL02 C programming handouts have been combined into one copy. You don't need to buy the handout if you already have one. |
| 成績評価の方法・基準 ／Grading method/criteria |
(ICTG class) In 100-point scale: - Regular quizzes give up to 20 points - Exercises, individual projects, hands-on sessions - up to 50 points - Final quiz - up to 30 points Bonus points can be given to the students for active participation in the classwork, for highly creative and high-quality exercise solutions, interesting questions, etc., to cover the deficit of the whole course score up to 20 points in 100-point scale. The students with high level of performance (more than 75% of max score for both regular quizzes and practical activities) are relaxed from the final quiz, thus, getting the maximum points for the latter activity. We don't hold any exam in this group. (C1-C6 classes) - Quizzes (conducted in every lecture) 20% - Computer programming exercises 30% - Examination 50% In principle, a score of at least 35% is required on the final exam to pass the course. |
| 履修上の留意点 ／Note for course registration |
(ICTG class) This course is based on the course PL01 "Introduction to Programming". Students must have basic knowledge of mathematical and algorithmic logics, understand major control structures such as branching, loops and expressions, and be able to use functions and to create arrays of elementary objects in their simple C programs, as well as to use structural types and corresponding functions. The course teaching language is English; good proficiency in English is critical for this course. (C1-C6 classes) Attendance of 2/3 or more for lecture and exercise each is required. |
| 参考(授業ホームページ、図書など) ／Reference (course website, literature, etc.) |
(ICTG class) The course instructor Dr. Evgeny Pyshkin has working experiences in software design, development, QA and tech writing. He worked as a software engineer for St. Petersburg Polytechnic University and participated in software projects with Spectrasize (Switzerland) as a developer, tech writer and project manager. You may find more information on https://u-aizu.ac.jp/~pyshe/. (C1-C6 classes) Reference books: "Programming in C: 1st step" The 3rd edition, Uchida, Ohmsha, Ltd. "Programming in C: 2nd step" The 2nd edition, Uchida, Ohmsha, Ltd. Course web page: file:///home/course/prog1/public_html/2026/welcome.html (only available via AINS computers) https://u-aizu.ac.jp/course/prog1/ (from outside the university (subset of the site above)) |
| Open Competency Codes Table Back |
| 開講学期 ／Semester |
2026年度／Academic Year 1学期 ／First Quarter |
|---|---|
| 対象学年 ／Course for; |
2nd year |
| 単位数 ／Credits |
4.0 |
| 責任者 ／Coordinator |
WATANOBE Yutaka |
| 担当教員名 ／Instructor |
WATANOBE Yutaka, PEI Yan, TEI Dogun, NITTA Koyo, SHIN Jungpil, KITAZATO Kohei, RAGE Uday Kiran, HAMADA Mohamed, DANG Nam Khanh |
| 推奨トラック ／Recommended track |
－ |
| 先修科目 ／Essential courses |
PL01 Introduction to Programming PL02 C Programming |
| 更新日／Last updated on | 2026/02/06 |
|---|---|
| 授業の概要 ／Course outline |
In this course, students will master Object-Oriented Programming (OOP)—an essential paradigm in modern software development—using the Java language. OOP is a design philosophy that provides software with high reusability, reliability, maintainability, and robustness. The lectures cover the fundamental theories of OOP, while the practical exercises focus on various implementation methods through concrete problem-solving. Particular emphasis is placed on implementing interfaces and design patterns, which are indispensable for mastering cutting-edge frameworks and libraries. |
| 授業の目的と到達目標 ／Objectives and attainment goals |
[Objectives] The objective of this course is to understand the essence of Object-Oriented Design for the efficient development and management of large-scale, complex software, and to be able to embody these principles through programming. Through this study, students will acquire the ability not only to write code but also to design systems that are resilient to change and highly reusable. This constitutes the essential foundational skill required in professional software development to correctly utilize and extend existing frameworks. [Attainment goals] By the end of this course, students will be able to: - Understand and apply the three pillars of OOP: Correctly interpret and develop programs using encapsulation, inheritance, and polymorphism. - Design abstractions using interfaces: Define interfaces as "contracts" to separate implementation from type, enabling the design and implementation of loosely coupled, change-resistant system architectures. - Apply design patterns: Explain how interfaces contribute to reusability and extensibility through representative design patterns (such as the Strategy pattern) and apply them to practical problems. [Relationship to Educational Goals] (A) Recognize professional and ethical responsibilities as an engineer; analyze societal needs using information science and technology; and define, solve, and evaluate technical challenges. (C) Apply specialized knowledge in mathematics, natural sciences, and information technology—along with scientific thinking skills such as logical reasoning and objective judgment—to problem-solving. [Competency Code] C-PL-001, C-PL-005, C-PL-007, C-SD-002, C-SD-003, C-SD-006 |
| 授業スケジュール ／Class schedule |
Session 1: Introduction Java / Java Platform Session 2: Object-Oriented Programming Objects / Classes / Encapsulation Session 3: Basic Syntax Variables / Operators / Control Structures Session 4: Classes and Objects Classes / Object Creation / Object References / Constructors Session 5: Inheritance (1) Inheritance / Subclasses / Superclasses / Casting / Overriding / Hiding Session 6: Inheritance (2) Class Hierarchy / IS-A Relationships / HAS-A Relationships / Object Class Session 7: Interfaces Interfaces / Types / Abstract Classes Session 8: Polymorphism (1) Polymorphism / Binding / Casting Session 9: Polymorphism (2) Constructor Chaining / Class Design Session 10: Packages Packages / Naming Conventions / Package Members / Source Code and Class Management Session 11: Exception Handling Types of Exceptions / Creating and Handling Exceptions / Defining Exception Classes Session 12: Numbers and Strings Classes for Numbers / Classes for Strings Session 13: Basic Input/Output (I/O) I/O / Streams Session 14: Selected Topics Each session consists of a lecture during the first two periods, followed by an individual programming exercise during the remaining two periods. Before each class, students are expected to study the lecture materials for the keywords listed in the schedule. Any assignments not completed during the exercise session must be finished by the specified deadline. Students should expect to spend approximately 8 hours on preparation and review for each session. |
| 教科書 ／Textbook(s) |
The Java Tutorial: https://docs.oracle.com/javase/tutorial/ |
| 成績評価の方法・基準 ／Grading method/criteria |
Exercises: 100 (maximum), Examination: 100 (maximum), Final grade: sqrt(Exercises × Examination) ※The parameters of the formula might be adjusted depending on the situation |
| 参考(授業ホームページ、図書など) ／Reference (course website, literature, etc.) |
The course coordinator Yutaka Watanobe has practical work experience. He collaborated with Givery Inc. to develop the programming skill check tool and materials which can be useful for personnel assessment, training and education. He has provided a number of problems and related test data as one of main contents. He also has experience in developing large scale software in practical use, such as development environments and educational support systems. Based on his experience, he can teach a wide range of algorithms and data structures. One of the course instructors Yan Pei has practical work experience. He worked for Neusoft Ltd. (China、CMMI5) and Alpine Electronics Europe D&R GmbH (Germany) for five years, where he attended and led software development projects (million LOC level) and teams, designed core algorithms, and applied for and obtained industrial patents. Based on these experiences, he can deliver lectures on algorithm and complexity, programming, and software engineering, etc. |
| Open Competency Codes Table Back |
| 開講学期 ／Semester |
2026年度／Academic Year 3学期 ／Third Quarter |
|---|---|
| 対象学年 ／Course for; |
3rd year |
| 単位数 ／Credits |
3.0 |
| 責任者 ／Coordinator |
NARUSE Keitaro |
| 担当教員名 ／Instructor |
NARUSE Keitaro, FAYOLLE Pierre-Alain, Idnin Pasya Bin Ibrahim, SAXENA Deepika |
| 推奨トラック ／Recommended track |
－ |
| 先修科目 ／Essential courses |
－ |
| 更新日／Last updated on | 2026/02/06 |
|---|---|
| 授業の概要 ／Course outline |
This course provides the fundamental knowledge of the programming language C++ to the students who have already learned the programming language C. It is an object oriented version of C, with the elements of class, inheritance, and dynamic binding, as well as the standard template library. |
| 授業の目的と到達目標 ／Objectives and attainment goals |
[Corresponding Learning Outcomes] (A)Graduates are aware of their professional and ethical responsibilities as an engineer, and are able to analyze societal requirements, and set, solve, and evaluate technical problems using information science technologies in society. (C)Graduates are able to apply their professional knowledge of mathematics, natural science, and information technology, as well as the scientific thinking skills such as logical thinking and objective judgment developed through the acquisition of said knowledge, towards problem solving. [Competency Codes] C-PL-001, C-PL-002, C-PL-003, C-PL-004, C-PL-005, C-PL-007, C-SD-003, C-SD-006 The students will learn the essence of C++ language such as class and object creation, data protection, class design, template function, generic function, iterator, containers and STL. The students will be able to develop software in C++ with the object oriented manner. |
| 授業スケジュール ／Class schedule |
Each class will be conducted with the first two periods in lecture format and the remaining period in exercise format. The topics covered by each of the weeks may be varied by an instructor. However, the total topics are same. Professor Naruse class #1 Introduction and string #2 Loop and counter #3 Data collection and iterator #4 Program and data organization #5 Sequential container #6 STL #7 Associative container #8 Template function and generic function #9 Class definition #10 Memory management #11 Abstract data type #12 Class behaving as value #13 Inheritance and dynamic binding #14 Automatic memory management and summary Professor Fayolle: 1) Introduction 2) Data abstraction (concept of class); Stream-based I/O 3) Pointers and references 4) Definition and declaration; const-correctness; the static keyword 5) Overloading; constructors (default constructor, copy constructor, copy assignment operator, move semantic); destructors 6) Inheritance (code reuse vs interface reuse; substitution principle; access control; overriding and virtual methods) 7) Exceptions and related topics (RAII; smart pointers) 8) Operator overloading 9) Generic programming (class template; function template) 10) Standard library containers 11) Iterators 12) Function objects; lambda functions 13) Standard library algorithms 14) Concurrent programming (thread; mutex; condition variables; future) [Preparation/Review] Preparation: Before each class, prepare by studying the lecture materials as well as implementing sample codes for the content indicated in the course plan. Review: Complete any unfinished exercises until the next class, as well as extra probelms and analysis shown in classes. The typical preparation/review time per session is 6–7 hours. |
| 教科書 ／Textbook(s) |
Each of instructors will let you know in classes. |
| 成績評価の方法・基準 ／Grading method/criteria |
Quiz: 10% Exercise: 30% Final: 60% Percentage can be changed by instructors |
| 履修上の留意点 ／Note for course registration |
None |
| 参考(授業ホームページ、図書など) ／Reference (course website, literature, etc.) |
Each of instructors will let you know in a class. |
| Open Competency Codes Table Back |
| 開講学期 ／Semester |
2026年度／Academic Year 1学期 ／First Quarter |
|---|---|
| 対象学年 ／Course for; |
4th year |
| 単位数 ／Credits |
3.0 |
| 責任者 ／Coordinator |
SUZUKI Taro |
| 担当教員名 ／Instructor |
SUZUKI Taro, NAKAJIMA Yu |
| 推奨トラック ／Recommended track |
－ |
| 先修科目 ／Essential courses |
Courses preferred to be learned prior to this course (This course assumes understanding of entire or partial content of the following courses) PL02 C Programming PL03 JAVA Programming I FU01 Algorithms and Data Structures I |
| 更新日／Last updated on | 2026/02/06 |
|---|---|
| 授業の概要 ／Course outline |
This course focuses on programming languages as typical computer languages and explains paradigms, models and technical points of programming languages in order to present the essence of programming languages. It will give students a notion of programming paradigm, which gives main concepts of programming, and explains the characteristics of each programming paradigm. We classify programming languages are classified based on programming paradigms and common features of programming languages belonging to the same programming paradigm. Semantics of programming languages are also explained. The programming paradigms dealt with this course are: procedural programming, functional programming, logic programming and object oriented programming. Especially, procedural and object oriented programming, as the basis of C, C++ and Java dealt with in the other programming courses, are fully studied. |
| 授業の目的と到達目標 ／Objectives and attainment goals |
[competency code] C-PL-001, C-PL-003, C-PL-005 While the other programming courses focus on the syntax and usage of programming languages, this course aims to provide students with the origins and principles of the groups of programming languages. By the end of the course students will be able to explain the following: 1. the characteristics of each programming paradigm 2. the features of procedural programming languages 3. the features of object oriented programming languages 4. syntax of programming languages 5. the abstract computation mechanism of programming languages through semantics |
| 授業スケジュール ／Class schedule |
Each class will be conducted with lectures and exercises. Lectures follows the textbook and supplementary materials. Supplementary materials of the textbook are distributed by LMS in advance. Exercises are assigned during classes, which are inserted between lectures. The class schedule is as follows 1. Introduction: programming paradigms and computation models Introduction to procedural programming: a machine model (RAM) 2. Functional programming (1) 3. Functional programming (2) 4. Logic programming (1) 5. Logic programming (2) Introduction to Object oriented programming 6. Syntax of programming languages 7. Procedural programming(1): control structures and data structures 8. Procedural programming(2): procedures 9. Mid term exam Object oriented programming(1): Objects, Abstract data types 10.Object oriented programming(2): features of object oriented programming 11.Object oriented programming(3): features of object oriented programming 12.Semantics of programming languages(1): operational semantics of RAM 13.Semantics of programming languages(2): operational semantics of procedural languages 14.Semantics of programming languages(3): denotation and axiomatic semantics The correspondence between classes and topics described above may be changed according to the progress of the course. Before each class, prepare by studying the textbook and supplementary materials according to the class schedule. The instructor occasionally asks students to study the textbook pages in advance. In such cases, it is assumed that students understand the content of the assigned pages in the next class. Also, review the textbook pages, supplementary materials and exercises assigned during every session. The typical preparation/review time per session is 3-5 hours. |
| 教科書 ／Textbook(s) |
Michio Oyamaguchi, Hiroshi Gomi. Programming Languages (in Japanese). Corona publishing Co.ltd. The class will basically follow the textbook, but there will be some topics that use handouts only distributed by the course instructor. |
| 成績評価の方法・基準 ／Grading method/criteria |
Exercise 30% Mid term exam 30% Final exam 40% |
| 履修上の留意点 ／Note for course registration |
Students are recommended to take Language Processing Systems at the same time, as it will deepen their understanding of programming languages when studied together with this course. In some topics, the class proceeds assuming that the students read the textbook and understand it to some extent before the lecture. In such topics, students who have not read the textbook in advance will not be able to follow the class. The course instructor uses |
| 参考(授業ホームページ、図書など) ／Reference (course website, literature, etc.) |
David A. Watt. Programming Language Design Concepts. Wiley. 2004. Hanne Riis Nielson and Flemming Nielson. Semantics with Applications: An Appetizer. Springer. 2007. Chris Hankin. Lambda calculi: a guide for computer scientists. Oxford University Press. 1994. The course instructor has work experiences: Prof. Suzuki was engaged in the development of C and Lisp language processing s\ ystems on Prolog inference machines with a multi-paradigm programming language\ combining logic and object-oriented programming paradigms, from 1987 to 1990 a\ t MTC Co.,Ltd. Based on his experience, he can teach theory and implementation \ of programming languages on various programming paradigms. |
| Open Competency Codes Table Back |
| 開講学期 ／Semester |
2026年度／Academic Year 1学期 ／First Quarter |
|---|---|
| 対象学年 ／Course for; |
3rd year |
| 単位数 ／Credits |
3.0 |
| 責任者 ／Coordinator |
PAIK Incheon |
| 担当教員名 ／Instructor |
PAIK Incheon, MATSUMOTO Kazuya |
| 推奨トラック ／Recommended track |
－ |
| 先修科目 ／Essential courses |
－ |
| 更新日／Last updated on | 2026/02/06 |
|---|---|
| 授業の概要 ／Course outline |
The Java Programming II is a course for the 3rd year students who had studied basics such as objects and classes, object oriented concept, exception handling, and I/O issues in Java. This course teaches some advance topics: annotation, reflection, threads, GUI, network programming, stream API and Android programming including new features in Java. In the first half of this course, we will study about topics related to Java language itself such as annotation, reflection, threads, stream, GC, and GUI. In the second half, we will experience development of distributed network applications in Java on the Web and smart mobile device. |
| 授業の目的と到達目標 ／Objectives and attainment goals |
The Java programming language is known for its secure, platform-independent nature, allowing applications to be developed and shared seamlessly across the Internet. By incorporating strong security features and a flexible design, Java provides a foundation not only for distributed networks but also for general-purpose software development. In many organizations, the ability to securely execute downloaded code on remote hosts is paramount. In alignment with these needs, this course provides students with the opportunity to strengthen their technical proficiency in Java through hands-on practice with graphical user interfaces (GUIs), generics, thread programming, networking, stream APIs, Android development, and the latest features introduced in recent Java releases. By exploring these topics, students will cultivate a deep understanding of how to design and build robust, secure applications that are capable of meeting real-world requirements. Furthermore, the course is designed to address following educational outcomes: - Students will learn the importance of maintaining high standards for data security, privacy, and platform interoperability, recognizing their role as future engineers in safeguarding and responsibly managing technology. - Through case studies and project work, students will evaluate how Java-based solutions can address diverse societal needs, such as improving healthcare systems, optimizing business operations, and enabling secure e-commerce platforms. - Students will be encouraged to identify real-world challenges, propose efficient Java-based solutions, and rigorously test or assess their implementations to ensure reliability, scalability, and maintainability. - Students will refine their ability to employ logical thinking and objective analysis in tasks like algorithm development, performance optimization, and data structure selection—key aspects of sophisticated Java programming. - By adopting a methodical approach to debugging, code reviews, and software design, students will cultivate analytical skills that enable them to assess trade-offs and make data-driven decisions. Throughout the course, learners will be tasked with practical assignments that require them not only to write robust code but also to consider the broader implications of their technological solutions. In doing so, they will develop the ability to critically evaluate technical approaches against organizational goals, ethical standards, and user requirements—skills that are vital for engineering professionals contributing to society in a rapidly evolving digital landscape. Overall, this course empowers students to become adept Java programmers who can apply solid theoretical knowledge, exercise responsible decision-making, and creatively solve problems. By blending advanced programming skills with ethical and societal awareness, graduates will be well-prepared to innovate, collaborate, and lead in any environment where secure and reliable software development in Java is essential. [Corresponding Learning Outcomes] • Advanced Object-Oriented Design: Students will be able to implement robust and type-safe software by mastering core Java principles, including polymorphism, abstract classes, and the effective use of Generics and the Collections framework. • Concurrent and Distributed Systems: Students will demonstrate the ability to develop complex applications by managing multi-thread synchronization and implementing network-based communications, such as RMI and web server architectures. • Modern Java and Platform Application: Students will be able to utilize modern functional programming features like Lambda expressions and Stream APIs to build interactive applications for both desktop (GUI) and mobile (Android) environments. [Competency Codes] C-PL-002, C-PL-003, C-PL-002, C-PL-005 [Preparation/Review] • Before each class session, read and understand the lecture materials (slides) and the corresponding sections in the practice notebook. After class, re-run the exercises, try implementing the provided example programs, and think about how to understand the code's meaning well and apply it. • The standard out-of-class learning time for this course is 430 minutes per session, broken down as follows: 60 minutes for preparation (reading slides + running example code), 70 minutes for review (completing and organizing exercises and examples), assignments 150 minutes (weekly assignment work: average), and additional review 150 minutes (thorough reading of relevant slides, reading reference books/papers, practice for the final exam). • Report assignments (14 sessions) are structured as 1-3 step tasks covering one session's content, assuming 150 minutes per task. The grace period for submission is one week. |
| 授業スケジュール ／Class schedule |
Session 1. • Lecture: Introduction and Java Fundamental Concept • Exercise: Exercise to code to use polymorphism, abstract class and interface Session 2. • Lecture: Java GUI (Events and AWT) • Exercise: GUI components - Window, Canvas, Delegated Event Handling with AWT Session 3. • Lecture: Java GUI (Swing) • Exercise: Swing Components and Animation Session 4. • Lecture: Generics and Inner Class • Exercise: Generics, Type save code, Wildcard Session 5. • Lecture: Collections • Exercise: Design of Comparable class with Iterator Session 6. • Lecture: Review & Application of GUI, Generics and Collections • Exercise: Design of GUI for a simple order system with Collections Session 7. • Lecture: Annotation, Documentation comments • Exercise: Annotation code design Session 8. • Lecture: Thread Basic • Exercise: Design of the Collatz Conjecture check with multi-threads Session 9. • Lecture: Thread Advanced (Synchronization of Multi-Threads) • Exercise: Design of safe Bank Teller with synchronization of multi-threads Session 10. • Lecture: Review & Application of Generics, Annotation, and Threads • Exercise: Application of Collection and multi-threads Session 11. • Lecture: Java Network Basic • Exercise: Design of simple Web server Session 12. • Lecture: Java Network Advance (Distributed Objects) • Exercise: RMI application with Callback Session 13. • Lecture: Lambda Expression and Stream API in Java • Exercise: Lambda expression, Word count using Stram API Session 14. • Lecture: Android Smart Phone Programming • Exercise: Demonstration of Android Smart phone applications |
| 教科書 ／Textbook(s) |
The Java Tutorial, 4th Edition, A Short Course on the Basics by S. Zakhour, S. Hommel, J. Royal, I. Rabinovitch, T. Risser, and M. Hoeber, Sun Microsystems, 2006 (English version), 2007 (Japanese Version). |
| 成績評価の方法・基準 ／Grading method/criteria |
1. Exercise Lab. and Report : 50% 2. Examination : 50% |
| 履修上の留意点 ／Note for course registration |
This course covers some advanced topics of Java. Therefore, it requires that students need to know basic concept of object oriented programming including good skill in C language. The prerequisite courses are: - Intro.Programming - C Programming - JAVA Programming I |
| 参考(授業ホームページ、図書など) ／Reference (course website, literature, etc.) |
* Reference 1. Arnold, James Gosling, and David Holmes, The Java Programming Language, 4th Edition, SUN, 2006. (Japanese version by Pearson Education) 2. Ivor Horton, Java 2 JDK 5 Edition, Wiley Publishing, 2005 3. C.S. Horstmann, G. Cornell, Core Java, Sun Microsystem Press 4. J. O’Neil, Teach Yourself JAVA, McGraw-Hill 5. Kathy Sierra and Bert Bates, Head First Java (Head First) 2nd edition, 2005; Japanese edition, 2006. |