Search

This chapter will discuss the difference between objects in Kotlin and instance of a class. This is important as many other object-oriented languages use these terms interchangeably. However, in Kotlin they are significantly different concepts, defined with different language constructs and used in different ways.

In this chapter we will look at the Android Studio and a simple Hello World style Android application.

This chapter considers exception and error handling and how it is implemented in Python. You are introduced to the object model of exception handling, to the throwing and catching of exceptions, and how to define new exceptions and exception-specific constructs.

In this chapter we will look at a simple Kotlin program and understand what it is doing. We will also modify it to become more interactive and will explore the concept of Kotlin variables (specifically vals and vars).

There are two further types of classes in Kotlin specifically Sealed Classes and inline Classes. This chapter will explore each of these. The chapter will conclude by introducing type aliases.

The Kotlin type system is comprised of more than just classes and objects; it includes interfaces and enumerated types. In this chapter we will explore the concept of an interface and what components can be defined within an interface. We will also consider a Kotlin language facility that allows an interface to be implemented via delegation. The chapter concludes by looking at enumerated types. An enumerated type is a type consisting of a set of named values also called elements or members of the enumeration. These values have a specific name and an ordering.

In this chapter we will explore the creation of a simple TicTacToe (or Noughts and Crosses) Android game.

In this chapter we will explore the idea of an implicit contract between an object and the code that uses that object. As part of this discussion we will explore what is meant by Duck Typing. Following this we will introduce the Python concept called a protocol. We will explore its role within Python programming and look at two commonly occurring protocols; the Context Manager Protocol and the Descriptor Protocol.

Regular Expression are a very powerful way of processing text while looking for recurring patterns; they are often used with data held in plain text files (such as log files), CSV files as well as Excel files. This chapter introduces regular expressions, discusses the syntax used to define a regular expression pattern and presents the Python re module and its use.

Python classes can hold data and behaviour that is not part of an instance or object; instead they are part of the class.

Testing software systems is not an easy thing to do; the functions, objects, methods etc. That are involved in any program can be complex things in their own right. In many cases they depend on and interact with other functions, methods and objects; very few functions and methods operate in isolation. Thus the success of failure of a function or method or the overall state of an object is dependent on other program elements.

In this chapter we will introduce the concepts of concurrency and parallelism. We will also briefly consider the related topic of distribution. After this we will consider process synchronisation, why object oriented approaches are well suited to concurrency and parallelism before finishing with a short discussion of threads versus processes.

Many programming languages have common logging libraries including Java and C# and of course Python also has a logging module. Indeed the Python logging module has been part of the builtin modules since Python 2.3. This chapter introduces logging, what to log, and what not to log.

The pervious four chapters have introduced the basic concepts behind object orientation, the terminology and explored some of the motivation. This chapter looks at how object orientation addresses some of the issues that have been raised with procedural languages. To do this it looks at how a small extract of a program might be written in a language such as C, considers the problems faced by the C developer and then looks at how the same functionality might be achieved in an object-oriented language such as Python. Do not worry too much about the syntax you will be presented with; it is mostly a form of pseudo code and it should not detract from the legibility of the examples.

The previous chapter illustrated the basic structure of a very simple web service application. We are now in a position to explore the creation of a set of web services for something a little more realistic; the bookshop web service application.

In this chapter we will step through the development of another Python program; this time the program will be to provide a simple calculator which can be used to add, subtract, multiple and divide numbers. The implementation of the calculator is base on the Function Decomposition performed earlier in the book in the Introduction to Structured Analysis chapter.

There are several testing frameworks available for Python, although only one, unittest comes as part of the typical Python installation. Typical libraries include unittest (which is available within the Python distribution by default) and PyTest. This chapter introduces the PyTest testing framework.

Computer Graphics are everywhere; they are on your TV, in cinema adverts, the core of many films, on your tablet or mobile phone and certainly on your PC or Mac as well as on the dashboard of your car, on your smart watch and in childrens electronic toys. This chapter introduces this topic.

In this chapter we will introduce the concept of Reactive Programming. Reactive programming is a way of write programs that allow the system to reactive to data being published to it. We will look at the RxPy library which provides a Python implementation of the ReactiveX approach to Reactive Programming.

Python has included a built-in logging module since Python 2.3. This module, the logging module, defines functions and classes which implement a flexible logging framework that can be used in any Python application/script or in Python libraries/modules.

Reading data from and writing data to a file is very common within many programs. Python provides a large amount of support for working with files of various types. This chapter introduces you to the core file IO functionality in Python.

Computer Art is defined as any art that uses a computer. However, in the context of this book we mean it to be art that is generated by a computer or more specifically a computer program. The following example, illustrates how in a very few lines of Python code, using the Turtle graphics library, you can create images that might be considered to be computer art.

There are two protocols that you are very likely to use, or will possibly need to implement at some point or other; these are the Iterable protocol and the Iterator protocols. These two closely related protocols are very widely used and supported by a large number of types.

There are a number of common data structures that are used within computer programs that you might expect to see within Python’s list of collection or container classes; these include Queues and Stacks. However, in the basic collection classes these are missing.

The Async IO facilities in Python are relatively recent additions originally introduced in Python 3.4 and evolving up to and including Python 3.7. They are comprised (as of Python 3.7) of two new keywords async and await (introduced in Python 3.7) and the Async IO Python package.

In this chapter we will explore the Matplotlib pyplot API. This is the most common way in which developers generate different types of graphs or plots using Matplotlib.

In this chapter we will return to the Hello World program and look at what it is doing. We will also modify it to become more interactive and will explore the concept of Python variables.

This chapter introduces a module that supports the generation of CSV (or Comma Separated Values) files.

The wxPython library is a cross platform GUI library (or toolkit) for Python. It allows programmers to develop highly graphical user interfaces for their programs using common concepts such as menu bars, menus, buttons, fields, panels and frames. This chapter provides an overview of the wxPython GUI library.

Earlier in this book we looked at some Python built-in types such as string, int and float as well as bools.

This chapter presents Abstract Base Classes (also known as ABCs) which were originally introduced in Python 2.6.

Modules and packages are two constructs used in Python to organise larger programs. This chapter introduces modules in Python, how they are accessed, how they are define and how Python finds modules etc. It also explores Python packages and sub-packages.

Monkey Patching is a term you might well come across when looking into the Python further or when searching the web for Python related concepts. It relates to the ability in Python to extend the functionality associated with a class/type at runtime.

The standard for accessing a database in Python is the Python DB-API. This specifies a set of standard interfaces for modules that wish to allow Python to access a specific database. The standard is described in PEP 249 (https://www.python.org/dev/peps/pep-0249)—a PEP is a Python Enhancement Proposal. This chapter introduces the Python DB-API.

There has been much hype around Functional Programming in recent years. However, Functional Programming is not a new idea and indeed goes right back to the 1950s and the programming language LISP. However, many people are not clear as to what Functional Programming is and instead jump into code examples and never really understand some of the key ideas associated with Functional Programming such as Referential Transparency.

In the following two chapters we will explore socket based and web service approaches to inter process communications. These processes may be running on the same computer or different computers on the same local area network or may be geographically far apart. In all cases information is sent by one program running in one process to another program running in a separate process via internet sockets. This chapter introduces the core concepts involved in network programming.

pygame is a cross-platform, free and Open Source Python library designed to make building multimedia applications such as games easy. This chapter introduces pygame, the key concepts; the key modules, classes and functions and a very simple first pygame application.

Python provides three functions that are widely used to implement functional programming style solutions in combination with collection container types. These functions are what are known as higher-order functions that take both a collection and a function that will be applied in various ways to that collection.

A Socket is an end point in a communication link between separate processes. In Python sockets are objects which provide a way of exchanging information between two processes in a straight forward and platform independent manner. In this chapter we will introduce the basic idea of socket communications and then presents a simple socket server and client application.

There are several different types of database system in common use today including Object databases, NoSQL databases and (probably the most common) Relational Databases. This chapter focusses on Relational Databases as typified by database systems such as Oracle, Microsoft SQL Server and MySQL. The database we will use in this book is MySQL.

The operating system is a critical part of any computer systems. It is comprised of elements that manage the processes that run on the CPU, how memory is utilised and managed, how peripheral devices are used (such as printers and scanners), it allows the computer system to communicate with other systems and it also provide support for the file system used.

As discussed in the last chapter; when you build an application of any size you will want to break it down into more manageable units; these units can then be worked on separately, tested and maintained separately. One way in which these units can be defined is as Python functions.

In this chapter we will explore the different ways that numbers can be represented by the built-in types in Python. We will also introduce the Boolean type used to represent True and False. As part of this discussion we will also look at both numeric and assignment operators in Python. We will conclude by introducing the special value known as None.

This chapter presents an introduction to the Scala programming language. As such, it is not intended to be a comprehensive guide. It introduces the basic elements of the Scala language, including Apps, discusses the concept of classes and instances and how they are defined, presents methods and method definitions, and considers constructors and their role.

The last chapter looked at various different types of user interface component available within Scala Swing. This chapter now looks at how user input, via those components, can be handled.