The Python Essentials course provides a comprehensive introduction to Python programming. This course is ideal for beginners and covers fundamental concepts, enabling students to build a strong foundation in Python. It emphasizes practical skills, offering hands-on exercises to apply theoretical knowledge. This course prepares students for more advanced studies in Python and is a stepping stone for careers in programming and data science.

Module 1

Familiarizes the student with Python’s basic methods for data formatting and extraction, along with the main data types and numeric operators, their mutual relations and precedence. Introduces the concept of variables and variable naming conventions. Presents the assignment operator, along with the rules governing the construction of expressions. Introduces data input and conversion.

Module 2

Familiarizes the student with the concepts of boolean values, to compare different values and to control the execution path using if- and if-else statements. Introduces the use of loops (while and for) and how to control their behavior using break and continue commands. Presents the difference between logical and bitwise operations. Introduces the student to the concept of lists and their processing, including iterations provided by loops, and slicing. Explains the idea of multi-dimensional arrays.

Module 3

Acquaints the student with defining and using functions – their reasoning, purpose, conventions, and pitfalls. Introduces the concept of passing arguments in different ways and setting their default values, along with mechanisms for returning function results. Explains issues of the name scope. Introduces new data aggregates: tuples and dictionaries and shows their role in data processing.

Module 4

Introduces the student to Python modules: their reasoning, their function, how to import them in different ways, and presents the content of some standard modules offered by Python. Introduces the way in which modules are joined together to make packages. Acquaints the student with the concept of an exception and Python’s implementation, including its applications, and instructions for raising. Introduces strings and their specific methods, along with their similarities and differences compared to lists.

Module 5

Introduces the student to the basics of OOP (Object Oriented Programming) and how they are adopted in Python, showing the difference between OOP and the classical, procedural approach. Introduces characteristic objective features: inheritance, abstraction, encapsulation, and polymorphism, along with Python-specific issues such as instance vs. class variables, and Python’s implementation of inheritance. Exceptions are discussed again in a more detailed way, showing their objective nature. Acquaints the student with Python’s generators (yield instruction) and closures (lambda statement). Demonstrates tools that Python developers can use to process (create, read, and write) files.

Module 0 (optional)

Acquaints the student with the basics of computer programming: how a computer works, how a program is executed, how a programming language is defined and constructed, what the difference is between compiling and interpreting, what Python is, how it is positioned among other programming languages, and what differentiates its various versions. Demonstrates a simple way to download, install, and run a Python environment on a personal computer.

The Java Basic + Advanced course at the School of Informatics is structured to provide comprehensive training in Java programming. The course aims to equip students with a deep understanding of Java fundamentals and advanced concepts. It’s designed to cater to both beginners and those looking to enhance their existing Java skills, making it ideal for a wide range of learners aiming to excel in this programming language.

Java Basics

• Define the scope of variables
• Define the structure of a Java class
• Create executable Java applications with a main method
• Import other Java packages to make them accessible in your code

Working With Java Data Types

• Declare and initialize variables
• Differentiate between object reference variables and primitive variables
• Read or write to object fields
• Explain an Object’s Lifecycle (creation, “dereference” and garbage collection)
• Call metho ds on objects
• Manipulate data using the StringBuilder class and its methods
• Creating and manipulating Strings

Using Operators and Decision Constructs

• Use Java operators
• Use parenthesis to override operator precedence
• Test equality between Strings and other objects using == and equals ()
• Create if and if/else constructs
• Use a switch statement

Creating and Using Arrays

• Declare, instantiate, initialize and use a one-dimensional array
• Declare, instantiate, initialize and use multi-dimensional array
• Declare and use an ArrayList

Using Loop Constructs

• Create and use while loops
• Create and use for loops including the enhanced for loop
• Create and use do/while loops
• Compare loop constructs
• Use break and continue

Working with Methods and Encapsulation

• Create methods with arguments and return values
• Apply the static keyword to methods and fields
• Create an overloaded method
• Differentiate between default and user defined constructors
• Create and overload constructors
• Apply access modifiers
• Apply encapsulation principles to a class
• Determine the effect upon object references and primitive values when they are passed into methods that change the values

Working with Inheritance

• Implement inheritance
• Develop code that demonstrates the use of polymorphism
• Differentiate between the type of a reference and the type of an object
• Determine when casting is necessary
• Use super and this to access objects and constructors
• Use abstract classes and interfaces

Handling Exceptions

• Differentiate among checked exceptions, RuntimeExceptions and Errors
• Create a try-catch block and determine how exceptions alter normal program flow
• Describe what Exceptions are used for in Java
• Invoke a method that throws an exception
• Recognize common exception classes and categories

Java Class Design

• Use access modifiers: private, protected, and public
• Override methods
• Overload constructors and other methods appropriately
• Use the instanceof operator and casting
• Use virtual method invocation
• Override methods from the Object class to i mprove the functionality of your class
• Use package and import statements

Advanced Class Design

• Identify when and how to apply abstract classes
• Construct abstract Java classes and subclasses
• Use the static and final keywords
• Create top-level and nested classes
• Use enumerated types

Object-Oriented Design Principles

• Write code that declares, implements and/or extends interfaces
• Choose between interface inheritance and class inheritance
• Develop code that implements “is-a” and/or “has-a” relationships
• Apply object composition principles
• Design a class using the Singleton design pattern
• Write code to implement the DAO pattern
• Design and create objects using a factory, and use factories from the API

Generics and Collections

• Create a generic class
• Use the diamond syntax to create a collection
• Analyze the interoperability of collections that use raw type and generic types
• Use wrapper classes and autoboxing
• Create and use a List, a Set and a Deque
• Create and use a Map
• Use java.util.Comparator and java.lang.Comparable
• Sort and search arrays and lists

String Processing

• Search, parse and build strings
• Search, parse, and replace strings by using regular expressions, using expression patterns formatching limited to: . (dot), * (star), + (plus), ?, \d, \D, \s, \S, \w, \W, \b. \B, [], ().
• Format strings using the formatting parameters: %b, %c, %d, %f, and %s in format strings.

Exceptions and Assertions

• Use throw and throws statements
• Use the try statement with multi-catch, and finally clauses
• Autoclose resources with a try-with-resources statement
• Create custom exceptions
• Test invariants by using assertions

Java I/O Fundamentals

• Read and write data from the console
• Use streams to read and write files

Java File I/O (NIO.2)

• Use the Path class to operate on file and directory paths
• Use the Files class to check, delete, copy, or move a file or directory
• Read and change file and directory attributes
• Recursively access a directory tree
• Find a file by using the PathMatcher class
• Watch a directory for changes by using WatchService

Building Database Applications with JDBC

• Define the layout of the JDBC API
• Connect to a database by using a JDBC driver
• Update and query a database
• Customize the transaction behavior of JDBC and commit transactions
• Use the JDBC 4.1 RowSetProvider, RowSetFactory, and RowSet interfaces

Threads

• Create and use the Thread class and the Runnable interface
• Manage and control thread lifecycle
• Synchronize thread access to shared data
• Identify potential threading problems

Concurrency

• Use java.util.concurrent collections
• Apply atomic variables and locks
• Use Executors and ThreadPools
• Use the parallel Fork/Join Framework

Localization

• Read and set the locale by using the Locale object
• Build a resource bundle for each local
• Load a resource bundle in an application
• Format text for localization by using NumberFormat and DateFormat

The C# course at the School of Informatics is designed to provide comprehensive training in C# programming. This course is suitable for both beginners and those looking to enhance their existing C# skills. It covers various aspects of the language, from basic syntax to more advanced features, ensuring students are well-equipped to handle real-world programming challenges using C#.

1. C# Fundamentals: Covering basic C# syntax, variable scope, class structure, and executable applications.

2. Data Types and Operations: Focusing on variable declaration, initialization, and operations including object lifecycle and garbage collection in C#.

3. Decision Constructs and Arrays: Using C# specific decision constructs like if-else, switch statements, and array handling including one-dimensional and multi-dimensional arrays.

4. Loop Constructs and Methods: Implementing various loop constructs and understanding methods, overloading, and constructors in C#.

5. Object-Oriented Programming in C#: Emphasizing on inheritance, polymorphism, encapsulation, and interfaces.

6. Advanced C# Concepts: Delving into delegates, events, exception handling, and other advanced features in C#.

7. C# Class Design and Advanced Topics: Covering access modifiers, method overriding, virtual method invocation, and specific C# class design considerations.