Title:  Formal Languages and Compilers 

Code:  IFJ 

Ac.Year:  2018/2019 

Sem:  Winter 

Curriculums:  

Language of Instruction:  Czech 

Public info:  http://www.fit.vutbr.cz/study/courses/IFJ/public/ 

Credits:  5 

Completion:  credit+exam (written) 

Type of instruction:  Hour/sem  Lectures  Seminar Exercises  Laboratory Exercises  Computer Exercises  Other 

Hours:  39  0  0  0  13 

 Exams  Tests  Exercises  Laboratories  Other 

Points:  55  20  0  0  25 



Guarantor:  Meduna Alexander, prof. RNDr., CSc. (DIFS) 

Deputy guarantor:  Křivka Zbyněk, Ing., Ph.D. (DIFS) 

Lecturer:  Burgetová Ivana, Ing., Ph.D. (DIFS) Křivka Zbyněk, Ing., Ph.D. (DIFS) Meduna Alexander, prof. RNDr., CSc. (DIFS) 
Instructor:  Kocman Radim, Ing. (DIFS) Křena Bohuslav, Ing., Ph.D. (DITS) Křivka Zbyněk, Ing., Ph.D. (DIFS) Martiško Jakub, Ing. (DIFS) Regéciová Dominika, Ing. (DIFS) Zobal Lukáš, Ing. (DIFS) 

Faculty:  Faculty of Information Technology BUT 

Department:  Department of Information Systems FIT BUT 

Prerequisites:  

Followups:  

 Learning objectives: 

  Familiarity with formal languages and their models. Grasp of compiler construction.  Description: 

  This course discusses formal languages and their models. Based on these models, it explains the construction of compilers. The lectures are organized as follows: (I) Basic notions: formal languages and their models, grammars, automata; compilers. (II) Regular languages and lexical analysis: regular languages and expressions, finite automata and transducers, lexical analyzer; Lex; symbol table. (III) Contextfree languages and syntax analysis: contextfree grammars, pushdown automata and transducers, deterministic topdown syntax analysis (recursive descent), the essence of deterministic bottomup syntax analysis; Yacc. (IV) Semantic analysis and code generation: semantic checks, intermediate code generation, optimization, code generation.  Knowledge and skills required for the course: 

  Knowledge of discrete mathematics.
 Learning outcomes and competencies: 

  Fundamental familiarity with the theory of formal languages. Ability of a compiler construction.  Why is the course taught: 

  The IFJ class gives a clear, comprehensive introduction to formal language
theory and its applications in computer science for undergraduate students. It
covers all rudimental topics concerning formal languages and their models,
especially grammars and automata, and sketches the basic ideas underlying the
theory of computation, including computability and decidability. Emphasizing
the relationship between theory and application, the class describes many
realworld applications, including computer science engineering techniques for
language processing and their implementation.
More specifically, IFJ  Covers the theory of formal languages and
their models, including all essential concepts and properties
 Explains how language models underlie compilers
 Pays a special attention to programming
language analyzers, such as scanners and parsers, based
on four language modelsregular expressions, finite automata, contextfree
grammars, and pushdown automata
 Discusses the mathematical notion of a Turing
machine as a universally accepted formalization of the intuitive
notion of a procedure
 Covers the general theory of computation,
particularly computability and decidability
In short, this class represents a theoretically oriented treatment of
formal languages and their models with a focus on their applications. It
introduces all formalisms concerning them with enough rigors to make all
results quite clear and valid. Every complicated mathematical passage is
preceded by its intuitive explanation so that even the most complex parts of
the class are easy to grasp. After taking this class, students
should be able to understand the fundamental theory of formal languages and
computation, write compilers, and confidently follow most advanced books on the
subject.  Syllabus of lectures: 

  Formal languages.
 Translation of languages and the structure of a compiler.
 Regular languages and their models: regular expressions and finite automata.
 Lexical analysis: lexical analyzer; Lex; symbol table.
 Contextfree languages and their models: contextfree grammars and pushdown automata.
 Syntax analysis: deterministic syntax analysis, FIRST and FOLLOW, LL grammars.
 Deterministic topdown syntax analysis: recursive descent.
 Deterministic bottomup syntax analysis: simple precedence analysis; Yacc.
 Semantic analysis and intermediate form generation.
 Optimization.
 Code generation.
 Chomsky hierarchy and the corresponding models.
 Remarks and summary. Preliminary discussion of the VYPe contents.
 Syllabus  others, projects and individual work of students: 

 Students in teams (3 through 4 students per a team) implement a compiler/interpreter of a simple programming language (including a documentation).  Fundamental literature: 


 Parsons, T. W.: Introduction to Compiler Construction. Freeman, New York, 1992.
 Study literature: 


 copy of lectures
 Meduna, A.: Automata and Languages. London, Springer, 2000.
 Meduna, A.: Elements of Compiler Design. New York, US, Tailor & Francis, 2008.
 Meduna, A.: Formal Languages and Computation. New York, Taylor & Francis, 2014.
 Controlled instruction: 

  In case of a serious obstacle (e.g. illness), the student should inform the
faculty about that and subsequently provide the evidence of such
obstacle.
 The midterm test takes place approximately in the middle of the semester without a spare or correction term (20 points). If student cannot attend the midterm test, (s)he can ask to derive
points from the evaluation of his/her first attempt of final exam. To
enter the final exam in this case, at least 12 points from project are required.
 To apply theoretical knowledge, students work on a team project (25 points). Continuously, the team leader checks team's progress. In case of illness of the most team members, the team can ask the responsible teacher to extend the time for the project.
 Finally, there is a final exam with two correction terms (55 points).
 Progress assessment: 

  There is a midterm test for 20 points without a spare or correction term. Students solve one team project during the semester (25 points) that is handed over before given deadline.  Exam prerequisites: 

  To be allowed to take the final written exam, the student has to obtain 20 points during the semester; out of these 20 points, at least four points has to be obtained for the programming part of the project.  
