|
Teacher name ： Syoji Kobashi
|
|
Basic specialized courses (Specialization-related courses)
The course numbering code represents the faculty managing the subject, the department of the target students, and the education category (liberal arts / specialized course). For detailed information, please download the separate manual from the upper right 'question mark'.
Syoji Kobashi,Takayuki Wada
Graduate School of Engineering
Thursday, 12:10–13:00
Room 6313, 3rd Floor, Building 6
Both in-person and online consultations are available. Please contact the instructor in advance via the UNIPA Q&A system.
For inquiries regarding this course, please contact all instructors via the UNIPA Q&A system.
A double circle indicates the most relevant DP number and a circle indicates the associated DP.
[Course Objectives] This course aims to develop fundamental software development skills in the field of engineering by systematically studying C programming from basic concepts to advanced topics.
In addition to fundamental elements such as variables, control structures, arrays, and functions, the course gradually covers more challenging topics, including pointers, structures, file operations, dynamic memory management, and recursive processing.
Through these topics, students will learn to organize design intent while being conscious of program behavior and memory structures, and to improve their logical problem-solving abilities by accurately implementing programs based on fundamental data structures and algorithms.
[Learning Outcomes] Upon successful completion of this course, students will be able to: - Explain the mechanisms of arrays, pointers, structures, file input/output, and dynamic memory management in C.
- Write programs that appropriately utilize pointers and structures.
- Develop basic programs that include recursive processing.
- Organize processing procedures for given problems and design and implement appropriate data structures and algorithms.
- Analyze program execution results and errors, and explain methods for improvement.
Subtitle: Practical Programming in C: From Fundamentals to Design and Applications Keywords:- C language, control structures
- arrays
- pointers
- functions
- recursion
- structures
- file operations
- dynamic memory management
- data structures, algorithms
[Course Overview] This course provides a systematic study of C programming from fundamental concepts to advanced topics. In addition to basic syntax, control structures, arrays, and functions, the course gradually addresses more challenging topics such as pointers, structures, file operations, dynamic memory management, and recursive processing. Lectures are conducted using actual code examples and their execution results. Comprehension check questions and short exercises are incorporated as appropriate to help students monitor and deepen their understanding. When the level of difficulty increases in the latter half of the course, the content is divided into smaller steps, with supplementary explanations and confirmation exercises provided to support student learning. Ultimately, the course aims to enable students to accurately implement programs while being conscious of design intent, based on fundamental data structures and algorithms. [Course Schedule] - Fundamentals of C Programming
(Variables, operators, standard input/output functions, bitwise operations) - Conditional Branches, Loops, and Arrays: Basics and Applications
(if statements, switch statements, while and for loops, one-dimensional and two-dimensional arrays) - Fundamentals of Pointers and Address Arithmetic
(Pointer variables, indirect referencing, relationship between arrays and pointers) - Functions and Recursive Functions
(Function definitions, parameters and return values, concepts of recursion) - Basic String Operations Using Pointers and Library Functions
(Strings, strlen, strcpy, strcmp) - Advanced String Processing Using Pointers
(String transformations, arrays of strings, pointer arithmetic) - File Operations and Error Handling
(Text file input/output, EOF detection, command-line arguments) - Fundamentals of Structures and Member Operations
(Structure definitions, initialization, typedef) - Advanced Use of Structures and Pointers
(Arrays of structures, pass-by-value and pass-by-reference) - Comprehension Check Exercises
(Comprehensive review and assessment of topics covered in Sessions 1–9) - Dynamic Memory Management and Structures
(malloc, free, dynamic allocation of structure arrays) - Complex Structures and Advanced Topics
(Bit fields, unions, handling of structured data) - Preprocessor Directives
(Macros, conditional compilation) - Fundamentals of Data Structures and Algorithms
(Basic algorithm design using arrays and structures) - Comprehensive Exercises and Achievement Assessment
This course is conducted in person.
Since no remote classes are offered, this course is not subject to the remote class credit limit.
Limited permission for use
Generative AI may be actively used for the purpose of deepening understanding of course content and supporting learning. Specifically, its use is permitted for checking program behavior, understanding concepts, and reviewing course materials.
However, the use of generative AI is strictly prohibited in comprehension check exercises and examinations. Submitting outputs generated by AI as answers or assignments without appropriate modification is not permitted.
In this course, generative AI is regarded solely as a supplementary tool to enhance understanding. If the use of generative AI beyond the scope permitted by the instructor is identified, course credit may not be granted or may be revoked.
Learning C Programming through Examples (2nd Edition)
Yayuki Oishi and Koichi Asakura
Muisuri Publishing
ISBN: 978-4-89641-309-0
Self-Study C (Revised Edition)
Shoeisha Co., Ltd.
ISBN: 978-4-7981-5024-6
Pre-class Learning- Before each lecture, students should read the relevant sections of the textbook and become familiar with the key concepts and terminology. In addition, students are encouraged to briefly review the content of the previous lecture and organize any points that were not fully understood before attending the class.
- As a guideline, students should spend approximately 1 hour before each lecture, for a total of 15 hours of preparation time.
Post-class Learning- After each lecture, students should review the textbook, distributed materials, and code examples to reinforce their understanding of the topics covered. In particular, it is important to confirm the relationship between program code and execution results and to understand the flow of processing.
- For topics that are not fully understood, students should conduct additional research and, when appropriate, use generative AI as a supplementary tool to deepen their understanding.
- Students are also encouraged to write and execute the example programs and end-of-chapter exercises provided in the textbook.
- As a guideline, students should spend approximately 2 to 3 hours after each lecture, for a total of 45 hours of review time.
Interactive Quizzes and Mini-tests- During lectures, short tests and comprehension check quizzes are conducted using tools such as Slido to assess students’ understanding in real time. After providing sufficient time for responses, the results are shared with the class, and review or supplementary explanations are given to reinforce learning.
- In addition, review-oriented confirmation questions are incorporated before tests to help students monitor their own level of understanding while progressing through the course.
Discussion-based Learning- Through quizzes and exercise problems, students are encouraged to apply the concepts and techniques they have learned to actual code and concrete examples.
- During exercises, students engage in peer discussions and pair work, providing opportunities to encounter different perspectives and problem-solving approaches.
- These activities go beyond one-way instruction and aim to deepen understanding through dialogue among students, fostering a proactive attitude toward learning.
[Grading Criteria]In this course, students are evaluated on their ability to understand the basic grammar of the C programming language and to appropriately apply the topics covered in the lectures—including conditional branching, loops, arrays, functions, pointers, structures, file operations, and dynamic memory management—to design and write programs, as well as to explain their behavior and processing logic.
Grades are determined by comprehensively assessing the level of achievement of the abilities specified in the course objectives and learning outcomes (knowledge and skills, thinking and judgment, and expressive ability), based on the results of comprehension check exercises and the final examination. Course credit is awarded according to the following criteria:S (90 points or higher): Judged to have fully achieved the learning objectives and to be at a level where the content can be explained accurately and logically.A (80 points or higher): Judged to have mostly achieved the learning objectives and to be at a level where standard programs can be appropriately written.B (70 points or higher): Judged to have achieved the learning objectives to a certain extent and to have a general understanding of fundamental content.C (60 points or higher): Judged to have achieved the minimum learning objectives.
[Grading Methods]Grades are comprehensively evaluated based on the following components:Comprehension Check Exercises: 40%Students’ level of understanding and thought processes are evaluated through comprehension check exercises based on the content covered in each class session.Final Examination: 60%A written examination covering the course content as a whole is conducted to evaluate students’ ability to read, write, and apply programs.
Please note that the use of any AI tools, including generative AI, is strictly prohibited in both the comprehension check exercises and the final examination.
The results of comprehension check exercises and the final examination will be disclosed after grading in a manner that allows students to review their performance. For comprehension check exercises, explanations will be provided during class, and correct answers and approaches will be shared to offer opportunities for deeper understanding. Depending on students’ level of understanding and requests, supplementary explanations or additional guidance may be provided. For the final examination, overall feedback and model answers will be made available through the UNIPA class profile function or similar platforms.Furthermore, upon students’ request, individual explanations regarding the intent of questions and approaches to answers may be provided using online meeting systems or similar tools.
This course is primarily intended for students who have completed Programming Fundamentals; however, completion of that course is not a prerequisite. Since this course is conducted on the assumption that the content covered in Programming Fundamentals has been learned, students who have not completed that course are strongly advised to review the relevant material in advance. This course is conducted in coordination with Computer Practice I and is designed to deepen understanding by having students write and execute actual programs based on the lecture content. Although it is not mandatory, students are strongly encouraged to enroll concurrently in Computer Practice I in order to gain more practical experience. If a student is absent from class due to illness or other unavoidable reasons, they are required to submit documentation such as a medical certificate (copies accepted) or a receipt issued by a medical institution that clearly indicates the student’s name and the date. Submitted documents will be returned after verification.
In cases where any differences arise between the English version and the original Japanese version, the Japanese version shall prevail as the official authoritative version.
|
