• A
  • A
  • A
  • ABC
  • ABC
  • ABC
  • А
  • А
  • А
  • А
  • А
Regular version of the site
Bachelor 2019/2020

Programming

Category 'Best Course for Career Development'
Category 'Best Course for Broadening Horizons and Diversity of Knowledge and Skills'
Type: Compulsory course (Business Informatics)
Area of studies: Business Informatics
Delivered by: Department of Information Systems and Digital Infrastructure Management
When: 1 year, 2-4 module
Mode of studies: Blended
Instructors: Калашников Сергей Владимирович, Вишняков Федор Николаевич, Sergey G. Efremov, Fidan Iskhakov, Vladimir Kurenkov, Kirill Mayboroda, Sergey Petropavlovsky, Tatyana Repetskaya, Казанцев Андрей Николаевич
Language: English
ECTS credits: 8

Course Syllabus

Abstract

In the 21st century programming has become an essential skill for anyone working in the IT-field, as it provides significant insight into how numerous technical devices and systems surrounding us operate. Programming languages and tools have evolved significantly over the years, which now enables people without a solid technical background to successfully master related courses. The present course is mandatory for students of the 38.03.05 “Business informatics” bachelor’s program at the Higher School of Economics. The course covers three modules and based on two programming languages - Python and C#. It is then followed by another two modules (not covered in the present syllabus) on object-oriented programming in C#
Learning Objectives

Learning Objectives

  • Give students an in-depth understanding of the main principles used in any high-level programming language, the basic data structures and algorithms on them
Expected Learning Outcomes

Expected Learning Outcomes

  • Know the basics of modern computer architecture
  • Be able to use the Python shell mode for simple arithmetic computations on integer numbers
  • Use the Python standard functions for input and output, including formatted output
  • Apply the conditional operator to solve branching tasks
  • Know the common code templates for loops
  • Apply the loop operator to process sequences of numbers or strings
  • Know the bitwise operations on integer numbers
  • Use the Python try-except block to handle program errors
  • Write modular code using functions
  • Be able to import functions from standard Python modules
  • Know the concept of a recursive function
  • Understand the fundamentals of the Python data model
  • Use the Python list collection with its standard functions
  • Know the approaches to evaluating algorithmic complexity, the Big-O notation
  • Understand the differences between standard sorting algorithms, their algorithmic efficiency
  • Use standard functions of the str class to perform basic text processing
  • Understand the main principles of regular expressions
  • Know the additional Python features related to linear collections
  • Understand the use-cases of associative containers
  • Use the standard dict and set classes
  • Use lambda functions, iterables and generators in Python programs
  • Use text files for application data storage
  • Know main data serialization formats
  • Know main approaches to graph representation
  • Be able to write breadth-first and depth-first search algorithms on graphs
  • Understand the main terms of object-oriented programming
  • Use the object-oriented programming paradigm in Python
  • Know the main features of C# as a programming language and the Dot Net framework
  • Know the ecosystem of external Python packages
Course Contents

Course Contents

  • Overview of modern computer architecture. Data representation in computers
    Computing history. Stored program computers. Von-Neumann architecture. Binary numeral system. Data representation in computers. Software structure. Source code and executable code.
  • Introduction to programming and the Python language
    Evolution of programming languages. High-level and low-level languages. Python overview. Python shell mode. Values, expressions and data types. Integer arithmetic operators. Integer division and its applications
  • Python script mode. Conditional execution
    Python script mode. Input and output. Formatted output including f-strings. Boolean expressions. Comparison operators. Boolean algebra. The if-elif-else operator. Code indentation rules
  • Loops
    Pre-condition and post-condition loops. Algorithms on loops: number multiplication, greatest common divisor, sequence processing, nested loops
  • Bitwise operations. Error handling techniques
    Storing bit states as numbers. Setting, clearing and inverting bits. Checking bit states with masks. Shift operators. Errors and their sources. Handling exceptions
  • Functions and modules. Name scopes. Recursive algorithms
    Modular program structure. Function definition in Python. Parameters and return values. Naming conventions. Standard functions from the built-in scope. Importing functions from modules. Math and random modules in Python. Recursive functions
  • Python data model. Lists
    How are values stored? The concept of a memory reference. Reference assignment. Mutable and immutable types. Python lists: creating a list, adding, removing, extracting values. Common algorithms on lists. Multi-dimensional tables stored as lists. The “for” loop. Tuples
  • Introduction to algorithmic complexity. Sorting algorithms
    Big-O notation. Algorithmic complexity. Linear and binary search. Simple sorting algorithms: selection sort, bubble sort, insertion sort. Divide and conquer techniques. Mergesort and quicksort
  • Strings. Advances techniques of text processing, regular expressions
    Storing text. Encoding tables. Specialized methods for string manipulation and processing. Regular expression language: main capabilities and samples. Extracting data to groups
  • Special Python syntactic features for linear collections
    Negative indexing. Slices and slice assignment. List comprehensions. List and tuple unpacking
  • Associative containers
    Associative containers: usage and internal structure. Special data structures – binary heap, binary tree. Container iteration. Generator functions and generator expressions
  • Elements of functional programming. Lambda functions, iterables, generators
    The concept of a pure function. Passing functions as parameters. Lambda functions. Iterables and iterators. Generator functions and generator expressions. The itertools module
  • File input-output
    File as an operating system abstraction. File attributes. File system. Absolute and relative paths. File access modes. Formats. Standard file operations. Text and binary files. The os module in Python. Serialization
  • Graph algorithms
    Graph terminology. In-memory graph representations: adjacency matrix, adjacency lists. Connectivity tasks. Depth-first search and breadth-first search. Dynamic connectivity. Edge-weighted graphs. Shortest path algorithms
  • Specialized Python packages. Python for data analysis
    Overview of available packages and their features. Integration with Excel
  • Introduction to object-oriented programming
    Classes and objects. Instance and class members. Basics of OOP. Python syntax related to OOP
  • Introduction to C#
    C# as a programming language. The modern .NET framework ecosystem. Intermediate code and just-in-time compilation. Simple types. Flow control statements. Standard collections
Assessment Elements

Assessment Elements

  • non-blocking In-class assessment 1
  • non-blocking Homework assignment 1
  • non-blocking Exam
  • non-blocking In-class assessment 2
  • non-blocking In-class assessment 3
  • non-blocking In-class assessment 4
  • non-blocking In-class assessment 5 (theoretical test)
  • non-blocking Homework assignment 2
  • non-blocking Homework assignment 3
Interim Assessment

Interim Assessment

  • Interim assessment (4 module)
    The final grade is determined by a weighted average of the scores on classroom assessment (CA), the average for homework assignments (HW) and the final exam (EX) FG= (0.3+w_a) ∙HW+(0.3-w_a)∙CA+0.4∙EX The formula includes a weight adjustment coefficient w_a that can be set by each student individually within the following limits: |w_a |≤((LQ+PJ+Act))/30 where LQ – average score for lecture quizzes normalized to [0,1] PJ – average score for PyJudge practice problems normalized to [0,1] Act – practice session activity, can be one of the three possible values [0, 0.5, 1]
Bibliography

Bibliography

Recommended Core Bibliography

  • Downey, A. (2015). Think Python : How to Think Like a Computer Scientist (Vol. Second edition). Sebastopol, CA: O’Reilly Media. Retrieved from http://search.ebscohost.com/login.aspx?direct=true&site=eds-live&db=edsebk&AN=1105725
  • Troelsen, A., & Japikse, P. (2017). Pro C# 7 : With .NET and .NET Core (Vol. Eight edition). [Place of publication not identified]: Apress. Retrieved from http://search.ebscohost.com/login.aspx?direct=true&site=eds-live&db=edsebk&AN=1637725

Recommended Additional Bibliography

  • Baka, B. (2017). Python Data Structures and Algorithms. Birmingham, U.K.: Packt Publishing. Retrieved from http://search.ebscohost.com/login.aspx?direct=true&site=eds-live&db=edsebk&AN=1528144