# Survey of Methods, Resources, and Formats for Teaching Constraint
Programming

Tejas Santanam
Georgia Tech
Atlanta, Georgia, USA
<EMAIL_ADDRESS>Helmut Simonis111This publication has emanated from
research conducted with the financial support of Science Foundation Ireland
under Grant number 12/RC/2289-P2 at Insight the SFI Research Centre for Data
Analytics at UCC, which is co-funded under the European Regional Development
Fund. For the purpose of Open Access, the author has applied a CC BY public
copyright licence to any Author Accepted Manuscript version arising from this
submission.
Insight SFI Centre for Data Analytics
School for Computer Science and Information Technology
University College Cork, Cork, Ireland
<EMAIL_ADDRESS>
###### Abstract

This paper provides an overview of the state of teaching for Constraint
Programming, based on a survey of the community for the 2023 Workshop on
Teaching Constraint Programming at the CP 2023 conference in Toronto. The
paper presents the results of the survey, as well as lists of books, video
courses and other tutorial materials for teaching Constraint Programming. The
paper serves as a single location for current and public information on course
resources, topics, formats, and methods.

##  1 Introduction

Constraint Programming (CP) is a declarative problem solving paradigm that has
been used over the last forty years to solve many industrial combinatorial
problems, and that can be used to express and solve problems with many
different problem solving technologies and methods. The approach to express
and solve a problem with CP is quite different to the programming in a
traditional programming language that most computer science students are
familiar with, therefore training of students in CP techniques is quite
important for the area.

After a successful workshop on Teaching Constraint Programming at the CP
conference in Cork in 2015, organized by Patrick Prosser, another workshop on
this topic was organized for CP 2023 in Toronto
222https://hsimonis.github.io/WTCP2023/. The papers and presentations from
that workshop can be found here. Many new CP systems and courses have appeared
since 2015, and the Covid-19 pandemic has led to many, perhaps only temporary,
changes in the way students are taught. As part of the workshop program, it
was decided to create a survey of the community on this topic. This paper
describes the survey, its results, and possible future actions intended to
improve teaching for CP. This paper is therefore intended to first present
information about courses being run, and materials being used, then to
identify gaps in the currently available materials, and then to suggest
possible types of courses for development.

While we received 51 replies to the survey, and had further feedback on the
topic during the discussions at the workshop, we are probably still missing
important information about courses held at other institutions, or in other
settings. The paper should be therefore seen as a working document, with new
links and materials being added over time.

The paper is structured as follows: We first (Section 2) describe the survey
we ran as part of the Workshop on Teaching Constraint Programming in 2023,
describing the methodology in Section 2.1, then presenting the results in
Section 2.2, and listing additional comments made by the participants in
Section 2.3, before drawing some conclusions of our analysis of the results in
Section 2.4. In the next Section 3 we list the course description links we
have received as part of the survey results. Most of the links point to a
description of the course only, but some include slides sets or videos. We
discuss course materials for such freely available courses in more detail in
Section 4. The next Section, Section 5, lists books on Constraint Programming
which are used for teaching CP. This is followed by a description of video
courses in Section 6, and of the existing literature on teaching of CP in
Section 7. We have also included a section on tutorials (Section 8) and on
additional content (Section 9) that can be helpful in developing teaching
materials. We discuss potential course structures for further development in
Section 10, before concluding the paper in Section 11.

##  2 Survey

As part of organizing the Workshop on Teaching Constraint Programming for CP
2023 we decided to try and poll the community about where and how CP is
taught. For this purpose, we designed an on-line questionnaire with Google
Forms, and then invited the community to participate.

There were three main points we wanted to study.

  * •

First, who is teaching Constraint Programming, is this purely happening at
universities, or are there other ways of learning about CP?

  * •

Can we determine common topics and areas covered, or are the courses widely
different from each other? Is there a consensus about the tools to be used?

  * •

Can we collect teaching resources that might be shared/reused by other
institutions?

In particular, we sought answers to the following questions:

  * •

Where are CP courses taught, who is the target audience, how many students are
reached? Are there regional gaps where CP is not visible?

  * •

If a CP researcher is not teaching a course on CP, what are the reasons?

  * •

Are these courses well established, or are they a rather recent introduction
to the teaching program?

  * •

How long is the course?

  * •

Is there a textbook that is widely used? If not, what other resources are
used?

  * •

Which topics are included in the course, which areas are left out?

  * •

Do the students get hands-on experience with a CP system, if yes, which system
is used?

  * •

What type of problems do the students solve?

  * •

After the experience during the Covid-19 pandemic, have universities returned
to a traditional teaching format?

  * •

Has there been an impact of the growing popularity of large language models
(LLM)?

###  2.1 Methodology

Table LABEL:tab:questions lists the questions asked in the survey, the format
of the answers, and a link to the presentation of the answers.

Table 1: Survey Questions Nr |  Question |  Reply Format | Answers
---|---|---|---
1 |  Does your institution offer a CP course or a course that covers some content around CP, SAT, or similar? | yes/no |  Figure 4
2 |  If no, what are the barriers or reasons? | text |  Page 4
3 |  If your institution offers such a course, is there more than one course that covers some aspect of this topic? (added during the survey) | yes/no | Answers incomplete
4 |  If you answered yes to the first question, who is the audience? | text |  Figure 5
5 |  How long has the course been taught? | Categories |  Figure 6
6 |  How many students does each offering of the class have? | Categories |  Figure 7
7 |  How many hours of instruction does the course involve in total? | Categories |  Figure 8
8 |  Does the class use a textbook or similar resource? | yes/no |  Figure 9
9 |  If you answered yes to the above question, list the resource below | text |  Figure 10
10 |  Does the class involve coding? | yes/no |  Figure 11
11 |  If you answered yes to the above question, list the language/software below | text |  Figures 12, 13
12 |  Have you seen any impact from Large Language Models (LLMs) such as ChatGPT in the course? | text |  Figure 17
13 |  Is the instruction primarily delivered through in-person interaction or through videos/MOOC? | text |  Figure 14
14 |  What sort of exercises do the students solve within the context of the course? | text |  Figures 15,16
15 |  Are there any public links you can provide on the course (ranging from course description to course materials)? | text |  Section 3
16 |  Any other comments that you would like to make? | text |  Section 2.3
Table 1: Survey Questions (cont’d)

###  2.2 Results

We now present the results of the survey, describing the answers to each
question in turn.

Figure 1 shows the participants per country, the largest number of
participants comes from France, followed by the US, and the UK. Many other
countries have three or fewer participants. Notable is the lack of entries
from Asia (excepting Hong Kong), Africa, and South America (excepting Colombia
with two entries from the same university). While the overall numbers seem
roughly in line with submission numbers at the CP conference (see Figure 2 for
the submitted/accepted papers for the CP2020 conference [50]), it points to a
lack of CP education in large parts of the globe. We need to investigate
further if these gaps are due to lack of awareness of the survey, or, more
seriously, a lack of CP interest in these areas.

$0$$2$$4$$6$$8$$10$$12$$14$$16$FRUSUKSEIECACOBEDEHKESAUNLPTNOITGRTRLU$15$$7$$4$$3$$3$$3$$2$$2$$2$$1$$1$$1$$1$$1$$1$$1$$1$$1$$1$Count
Figure 1: Participants By Country
$0$$2$$4$$6$$8$$10$$12$$14$$16$$18$$20$$22$$24$$26$$28$$30$$32$FRUSAUDEUKCASWATPOCNCZITSGPTBEGRJPNOIEESINDKBDCOROAERUDZCount
(Fractional Value per Co-Author Affiliation)AcceptedRejected Figure 2:
Accepted/Rejected Papers by Country for the CP 2020 conference [50]

Figure 3 shows the participants by country and institution. Some institutions
had multiple participants, entering different courses, so the total number of
entries does not match the total number of participants. Note that some well-
known CP centres are missing (e.g. Vienna, Singapore, Barcelona), we should
look for feedback from these centres.

  * •

France

    * –

CRIL Lens

    * –

Montpellier

    * –

Grenoble

    * –

Sophia Antipolis

    * –

Nice

    * –

Cote Azur

    * –

Ecole Polytechnique

    * –

IMT Atlantique

    * –

INRAE

    * –

UPHF Valenciennes

    * –

Cosling

    * –

IRISA, Rennes

    * –

INRIA

  * •

USA

    * –

UT Dallas

    * –

Brown

    * –

CMU

    * –

UConn

    * –

City University New York

    * –

Georgia Tech

    * –

Lincoln, Nebraska

  * •

Canada

    * –

Laval

    * –

Poly Montreal

    * –

Toronto

  * •

UK

    * –

Edinburgh

    * –

York

    * –

St Andrews

    * –

Glasgow

  * •

Sweden

    * –

Lund Univ

    * –

RISE

    * –

Upssala Univ

  * •

Belgium

    * –

UCLouvain

    * –

KU Leuven

  * •

Germany

    * –

Fraunhofer

    * –

TU Cottbus

  * •

Ireland

    * –

Munster Technical University

    * –

University College Cork

  * •

Others

    * –

UDG Girona, Spain

    * –

CUHK, China

    * –

Monash, Australia

    * –

Delft, The Netherlands

    * –

Lisbon, Portugal

    * –

Bologna, Italy

    * –

Simula, Norway

    * –

Western Macedonia, Greece

    * –

Universidad del Valle, Colombia

    * –

Izmir,Turkey

    * –

Univ. Luxembourg, Luxembourg

Figure 3: Participants by Institution

Not all survey participants run a CP course at their institutions, 10 out of
51 participants answered ”No” in Figure 4.

YesNo$0$$10$$20$$30$$40$$41$$10$Count Figure 4: Does your Institution offer a
CP Course?

The reasons given vary, some of the reasons stated are:

  * •

(4) No students (industry, research centre)

  * •

(2) Time/Workload

  * •

(2) Only as part of a more general course

  * •

(1) No interest by students

  * •

(1) Not allowed by institution

  * •

(1) CP is not a recommended course in the ACM Curricula Recommendations.

We did receive one reply describing courses run by industry. These courses are
run on-demand for professionals, using proprietary teaching materials on
modelling industrial problems.

Figure 5 shows the intended audience for the courses. Some institutions offer
courses at the undergraduate and graduate level, while others allow both
undergraduates and graduate students to attend the same course. The total
number of entries therefore does not match the number of participants running
courses. One course ([11]) is provided for PhD students as part of a general,
national training program for AI in Ireland.

UndergradGraduateMastersPhD students$0$$10$$20$$30$$20$$34$$3$$1$Count Figure
5: Intended Audience of Course

Many of the courses have been running for many years, as Figure 6 shows. Some
participants commented that while a course has been running for multiple
years, the content of the course has changed over time, adapting different
tools and objectives. On the other hand, four courses have been running for
three or fewer years, and one course is starting this year.

10+ years5-10 years3-5 years1-3 years0-1
yearsstarting$0$$5$$10$$15$$20$$20$$9$$12$$4$$0$$1$Count Figure 6: How long
has the course been offered?

Enrollment numbers vary quite significantly. Some courses are run with ten or
fewer students, while two are marked as having 100+ students.

0-1010-2020-5050-100100+$0$$5$$10$$15$$6$$16$$17$$4$$2$Count Figure 7: How
many students does each offering of the course have?

The majority of the courses offered provide between 20 and 50 hours of
instruction, as Figure 8 shows. One course provides more than 100 hours of
instruction.

0-2020-5050-100100-200$0$$10$$20$$30$$9$$32$$4$$1$Count Figure 8: How many
hours of instruction does the course have?

Figure 9 shows that relatively few (8) courses use a textbook, while most do
not.

YesNo$0$$10$$20$$30$$40$$8$$38$Count Figure 9: Does the class use a textbook
or similar resource?

The participants were asked which resources were used, the answer shows that
there is little commonality in resources used. Each course largely depends on
its own materials. We will discuss textbooks in more detail in Section 5.
Figure 10 lists the resources mentioned.

  * •

(2) Krzysztof Apt ”Principles of Constraint Programming” [3]

  * •

P. Hofstedt, A. Wolf ”Einführung in die Constraint-Programmierung”[24]

  * •

R. Dechter ”Constraint processing” [12]

  * •

Jupyter notebooks

  * •

MiniZinc Handbook

  * •

EdX MOOC

  * •

MiniCP material

  * •

Krzysztof Kuchcinski, ”Modeling and Optimization of Embedded System with
Constraint Programming: Principles and Practice” 333I did not find a
description of this book?

  * •

Global Constraint Catalog [5]

  * •

Choco-solver manual

  * •

Research papers

Figure 10: Resources

Nearly all courses involve coding (Figure 11), only one respondent answered
”No”.

YesNo$0$$10$$20$$30$$40$$45$$1$Count Figure 11: Does the class involve coding?

We asked which CP system and programming language were used in the course,
multiple answers were possible in a free-form field. Figure 12 shows the
answers for the CP system, Figure 13 shows the answers for the programming
language used. In Figure 12, the largest number of replies mentioned MiniZinc
[37] (the back-end solver used was not mentioned in most entries, but Gecode
[48] was mentioned several times). This was followed in frequency by Choco-
solver [42] and MiniCP [36], which is rather interesting given that its
release is quite recent. Five replies stated that the students can work with
any CP system they like, while a large number of system were only listed in
one reply.

The following systems were mentioned by only one participant:

  * •

SICStus Prolog [9]

  * •

SAT

  * •

Conjure [1]

  * •

Savile Row [39]

  * •

PyCSP3 [32]

  * •

ACE [30]

  * •

pysat

  * •

Z3

  * •

Clingo

  * •

OPL [22]

  * •

Cplex

  * •

Hava

  * •

JaCoP [28]

  * •

SWI Prolog [58]

  * •

Essence’

  * •

Torch

  * •

pytoulbar2

  * •

ECLiPSe [47]

  * •

OR-Tools

  * •

Gecode [48]

MiniZincChocoMiniCPCP OptAnyOthers$0$$5$$10$$15$$20$$20$$9$$5$$3$$5$$20$Count
Figure 12: Solver/System Used? (Multiple Allowed)

The most common programming language used (Figure 13) is Java, followed by
Python, and different versions of Prolog (ECLiPSe [47], SICStus Prolog [9] and
SWI Prolog [58]), and finally C++. In five replies it is stated that the
students can pick any language they like. Note that MiniZinc is normally used
with its own IDE, without using a host language, but that some answers
mentioned the use of Python to host the MiniZinc back-end solver. The
following languages were mentioned once each.

  * •

Julia

  * •

Scala

JavaPythonPrologC++AnyOthers$0$$2$$4$$6$$8$$10$$12$$11$$8$$5$$4$$5$$2$Count
Figure 13: Programming Language Used? (Multiple Allowed)

The last question was about the delivery of the courses. During the Covid-19
pandemic, many courses had to use a virtual format, but this has not been
continued after the restrictions were lifted. The vast majority of the courses
is still given in-person, as shown in Figure 14. Some courses use a flipped
format, where lectures are pre-recorded, and are available on-line, while the
direct interaction with the students is used to answer questions, and provide
feedback.

In-personVirtuallyMixedFlipped$0$$10$$20$$30$$40$$41$$2$$1$$2$Count Figure 14:
Is the instruction primarily delivered through in-person interaction or
through videos/MOOC? ModellingSolver DesignSearchGlobal
ConstraintsAlgorithms$0$$10$$20$$30$$29$$10$$7$$6$$2$Count Figure 15: What
sort of exercises do the students solve (Free Form, Areas)?
PuzzlesSchedulingLogisticsTime TablingPlanning$0$$2$$4$$6$$7$$7$$4$$2$$1$Count
Figure 16: What sort of exercises do the students solve (Free Form, Types)?

###  2.3 Additional Comments

We provided a free form field to provide additional feedback. Several of the
participants noted that they teach CP as part of a larger course, we probably
did not consider the implications of that in the design of the questionnaire
carefully enough.

Another comment was that in multiple places there are more than one course on
CP, again the design of the survey did not allow for that.

More specific comments were:

> The course is pretty challenging for students without a lot of computational
> thinking, and since it doesn’t have many direct prerequisites there are
> always a number of weak students who struggle a lot. Partly because we have
> a generation of weak students who complete assignments by a combination of
> LLM and reddit and trial and error!

> Students who take the course love it.

> When they start, they have had a Prolog class and they think Prolog is
> difficult. At the end of the CP class, they think Prolog is quite easy
> compared to constraints. We would need a 3rd LP course…

The student experience seems to differ widely depending on the topics included
in the course, the background of the students, and the overall teaching aims.
But a common comment was that students struggle with the declarative nature of
CP, perhaps more so if they are only used to writing imperative programs.

> This is a timely workshop because the ACP EC is currently discussing the
> dissemination of CP through turnkey teaching modules that can be
> incorporated into university courses and through turnkey tutorials that can
> be proposed in related conferences.

There seems to be a need for different course formats, from short overviews
that can be easily included in another course, to modelling courses on how to
use CP, to more detailed engineering courses on how to write CP solvers.

> Prolog with appropriate constraint solving and constraint-based modeling
> libraries should be the right language to teach CP (unlike MiniZinc for
> several reasons: explicit logical foundations, constraints as answers not
> just instantiated solutions, possibility to program constraint solvers
> without changing of language, no error message following transformation to
> FlatZinc)

Clearly, people are passionate about their specific approach to presenting
Constraint Programming. This seems to indicate that it might be difficult to
come up with a single, uniform course format that satisfies everybody.

> Setting up a shared resource of teaching materials would be great.

> And thank you for your initiative collecting this information. Big service
> to the community.

> I cannot attend CP but I would like to have a summary of what you discussed.

On the other hand, there clearly is an interest in shared resources, and
providing some information how other people teach CP.

###  2.4 Analysis

It is important to note that we are trying to generalize from a relatively
small sample. There were 51 responses to the survey, we don’t know how many
places that do teach CP are not included. Given that caveat, the following
conclusions can be drawn:

  1. 1.

There are large areas of the world (especially many parts of Asia, Africa, and
South America) where Constraint Programming is not taught. It should be one of
the objectives of the ACP to remedy this.

  2. 2.

CP is almost exclusively taught at universities, mostly at the advanced
undergraduate and graduate level. We did not receive replies from industry
about in-house courses, nor third party courses being used.

  3. 3.

In universities where CP is not taught, the reasons given are time needed to
develop a course, little interest from students, or from the university
itself. In many of these cases, providing shared resources through the ACP
might be helpful to overcome these difficulties.

  4. 4.

Non-traditional courses, like MOOC (Massive Open Online Courses), have reached
a much wider audience than most CP courses. Some exceptional courses at
universities reach more than 100 students per instance.

  5. 5.

Many existing CP courses have been running for many years, showing that the
topic is well established at their university.

  6. 6.

A course format of a one-semester course (approximately 24-40 hours taught) is
quite common, but CP is also taught as a sub-module in more general courses,
or as a significantly longer course.

  7. 7.

There currently is no single, standard textbook that is widely used. Most
courses rely on their own resources, and using tutorials and manuals provided
by the CP systems used.

  8. 8.

Nearly all courses involve student exercises through coding, mostly focused on
modelling simple problems. The use of puzzles is widespread, as well as using
scheduling and logistics examples.

  9. 9.

There is little consensus on which CP system should be used, but MiniZinc is
used for many courses that focus on modelling. Many tools mentioned are only
used in a single location.

  10. 10.

Most universities have reverted to a standard in-person course format after
the disruption caused by the Covid-19 pandemic.

  11. 11.

At the time of the survey, the impact of large language models (LLM) on the
courses was still quite limited, but a significant impact is expected by many
participants.

##  3 Course Descriptions

Table LABEL:tab:coursedescriptions gives a more detailed overview of the
courses taught at different universities which were mentioned in the survey
responses. The table lists them in order of reply, we list the country and
name of the organization providing the course, the language in which is course
is taught, and the CP system that is used. If that is not provided in the
available material, the entry is left blank. We also list the indented
audience, and the format of the information provided. Possible values are CD
for a course description, WB for workbook, Slides, if the slides of the course
are available at the link given, or Video, if a video course is described. The
last column gives the name of the course, together with a link to a web page
which provides the information. Some links might get stale quite quickly, as
the descriptions often are linked to a specific semester or year when the
course is taught. We see that the majority of the courses are given in
English, but there may be versions of the material in other languages, e.g.
French, German or Italian, if a course is taught in different languages
depending on the student group.

For some organizations, like UCC or Montpellier, the link to the course
description goes to a higher-level curriculum overview, and you have to find
the relevant entries with the name of the course provided.

Table 2: Course Descriptions Country |  Organization |  Language |  CP System | Audience | Format |  Course Name/Link
---|---|---|---|---|---|---
US |  UT Dallas |  English |  Prolog |  | CD |  Computational Logic
UK |  St Andrews |  English |  |  | CD |  Constraint Programming
HK |  Chinese University, Hong Kong |  English |  |  | CD |  Combinatorial Search and Optimization with Constraints
US |  Brown University |  English |  IBM Optimization Studio |  | CD |  Foundations of Prescriptive Analytics
FR |  University Artois |  English |  |  | CD |  Constraint Programming
BE |  KU Leuven |  English |  |  | CD |  Advanced Programming Languages for A.I.
CA |  University Laval |  French |  |  | Slides |  Optimization
CA |  Polytechnique Montreal |  French |  |  | CD |  Programmation par contraintes
SE |  Uppsala University |  English |  MiniZinc, MiniCP | Masters | CD |  Combinatorial Optimisation and Constraint Programming
|  |  English |  MiniZinc, Gecode | Masters | Slides |  Combinatorial Optimisation and Constraint Programming
|  |  English |  MiniZinc | Masters | CD |  Modelling for Combinatorial Optimisation
PT |  Tecnico Lisboa |  Portuguese |  |  | CD |  Algoritmos para Lógica Computacional
BE |  Louvain |  English |  |  | Video |  MiniCP: A lightweight Constraint Programming Solver
IE |  University College Cork |  English |  Choco-solver |  | CD |  Constraint Programming and Optimisation
|  |  English |  lp-solve | Masters | CD |  Optimisation
|  |  English |  MiniZinc | PhD students | CD |  Artificial Intelligence Methods
SE |  Lund University |  English |  |  | CD |  Constraint Programming
FR |  Lifeware, INRIA |  French, English |  SWI Prolog |  | CD |  Modèles et Algorithmes à base de Contraintes pour l’Aide à la Décision
|  |  English |  SWI Prolog |  | CD |  Relational Programming
FR |  INRA |  French |  |  | Slides |  ENAC course on graphs and networks
NO |  Simula |  |  |  |  |  https://www.simula.no/education/courses/crash-course-machine-learning
IT |  Univ Bologna |  English |  MiniZinc | Masters | CD |  Decision Making with Constraint Programming
|  |  English |  MiniZinc | Masters | CD |  Combinatorial Decision Making and Optimization
UK |  York |  English |  |  | CD |  Constraint Programming
FR |  INRAE |  French |  Choco-solver | Masters | CD |  Modèles et algorithmes pour les problèmes d’optimisation complexes de l’IA
|  |  |  Python |  | WB |  VisualSudoku-e.ipynb
|  |  |  Python |  | WB |  VisualSudoku.ipynb
|  |  |  Python |  | WB |  Master DC1e.pynb
|  |  |  |  |  |  https://colab.research.google.com/drive/1tzw36ImzdtLWDrbmleEYRewDhRwmIixe?usp=sharing
|  |  |  Python |  | WB |  VariableElimination.ipynb
FR |  Université Polytechnique Hauts-de-France |  |  |  |  |  https://filesender.renater.fr/?s=download&token=c538ffa0-96fb-4156-843e-959eb8ba7af0
DE |  BTU Cottbus-Senftenberg |  German |  Choco-solver, ECLiPSe | Masters | CD |  Einführung in die Constraint-Programmierung
TR |  DOKUZ EYLUL UNIVERSITY, Izmir |  |  OPL |  | CD |  Constraint Programming
FR |  Université Côte d’Azur |  French |  |  | CD, Slides |  Résolution de problèmes
US |  Lincoln, Nebraska |  English |  |  |  |  Foundations of Constraint Processing
LU |  University of Luxembourg |  English |  MiniZinc |  | Slides |  Intelligent System, Constraint Programming
CA |  University of Toronto |  English |  | Grad | CD |  Advanced Propositional Reasoning
FR |  Montpellier |  French |  |  | CD |  HAI9010I Contraintes
AU |  Monash University |  English |  MiniZinc | Masters | CD |  Modelling discrete optimisation problems

##  4 Course Materials

Some responses to the survey gave links to detailed sets of resources for
number of courses on CP and related topics, we give an overview in Table 3,
and discuss each such course in turn below. The materials here are not an
exhaustive list, but rather a list of courses for which further materials were
available to the authors.

Table 3: Course Materials

Authors |  Title | Year | Language | CP System | Length
---|---|---|---|---|---
H. Simonis |  ECLiPSe ELearning Course[49] | 2009 | English |  ECLiPSe[47] | 20 chapters
Marie Pelleau |  Résolution de problèmes |  | French | - | 5 chapters
Pierre Talbot |  Intelligent System, Constraint Programming |  | English | - | 61 slides
Alexandre Gondran, Simon de Givry |  ENAC course on graphs and networks | 2021 | French, English | - | 273 slides
Claude-Guy Quimper |  Optimization | 2022 | French | - | 9 chapters
Pierre Flener |  Modelling for Combinatorial Optimisation | 2023 | English | MiniZinc | 11 chapters

###  4.1 ECLiPSe Elearning Course

The ”ECLiPSe Elearning Course” by H. Simonis consists of a series of lectures
on using the ECLiPSe system for CP. The slides are available under an CC-NC-SA
licence, and cover the following 20 lectures.

  1. 1.

Introduction (35 slides)

  2. 2.

First Steps

  3. 3.

Constraint Application Overview (34 slides)

  4. 4.

Basic Constraint Reasoning - SEND+MORE=MONEY (70 slides)

  5. 5.

Global Constraints - Sudoku (87 slides)

  6. 6.

Search Strategies - N-Queens (54 slides)

  7. 7.

Optimization - Routing and Wavelength Assignment (RWA) (46 slides)

  8. 8.

Symmetry Breaking - BIBD (52 slides)

  9. 9.

Choosing the Model - Sports Scheduling (95 slides)

  10. 10.

Customising Search - Progressive Party (64 slides)

  11. 11.

Limits of Propagation - Costas Array (50 slides)

  12. 12.

Systematic Development (28 slides)

  13. 13.

Visualization (54 slides)

  14. 14.

Finite Set and Continuous Variables - SONET Design Problem (24 slides)

  15. 15.

Network Applications (85 slides)

  16. 16.

More Global Constraints - Car Sequencing (60 slides)

  17. 17.

Using Mixed Integer Programming - RWA II (35 slides)

  18. 18.

A Hybrid Model - RWA III (47 slides)

  19. 19.

Comparing Technologies - RWA IV(52 slides)

  20. 20.

Working with Implications - Shikaku (57 slides)

Most lectures introduce some concept based on a specific puzzle or problem,
and provide a visualization of the problem and the solution process, based on
the visualization tools described in [51]. Notable gaps in the course are
scheduling and placement problems, these were not included as ECLiPSe did not
possess the required global constraints. A Chapter on packing based on [52,
53] using SICStus Prolog [9] was used in some of the derived courses below, a
Chapter on Methodology was added for the ACP Summer School in 2018, and the
Chapters on visualization and applications have been replaced in the CRT-AI CP
week with more up-to-date versions, as described in Section 8.

Selected elements of the course have been used for a number of courses, Summer
Schools and presentations, typically only including some of the chapters of
the overall course. Examples are:

Doctoral School on Decision Theoretic AI, Cork, 2009

Chapters 1, 4, 5, 6, 9, 3

ACP Summer School 2009, Cork

Chapters 1, 4, 5, 6, 9, 3

CPAIOR 2009 Master Class

Chapters 5, 9, 8, 10, 16, 18

JFPC 2010 Invited Talk

Chapters 13, 5, 9

Dagstuhl, Germany

Chapters 1, 4, 5, 6, 10

CP and Verification, Izmir, Turkey

ICON Summer School, 2015, Sicily, Italy

Chapters 1, 4, 5, 6, 10

ACP Summer School 2016, Cork

Chapters 1, 4, 5, 6, 9, 3

ACP Summer School 2018, Jackson, Wy

Chapters 4, 5, 6, 9, 10, 16

CRT-AI CP Week 2019, 2021, 2022, 2023, 2024

Chapters 4, 5, 6, adapted to MiniZinc

###  4.2 Résolution de problèmes

The course ”Résolution de problèmes” by Marie Pelleau of the Université Côté
d’Azur in France consists of five lectures that deal with different aspects of
combinatorial problem solving:

  1. 1.

Introduction (29 slides)

  2. 2.

Modelling (9 slides)

  3. 3.

Greedy Methods (21 slides)

  4. 4.

Local Search (25 slides)

  5. 5.

Constraint Programming (41 slides)

###  4.3 Graphs and Networks

The course ”Graphs and Networks” by Alexandre Gondran and Simon de Givry for
ENAC (Ecole Nationale de l’Aviation Civile) presents a lot of the material
that one would need to know to understand the filtering methods used by
important global constraints, while talking about constraint reasoning at the
end. Main topics covered are:

  1. 1.

Graphs and their properties

  2. 2.

DFS, BFS, shortest path, MST

  3. 3.

TSP, VRP

  4. 4.

Matching

  5. 5.

Graph Coloring

  6. 6.

Network Flow

  7. 7.

NP completeness

  8. 8.

CSP

###  4.4 Combinatorial Optimization

The ”Combinatorial Optimization” course by Claude-Guy Quimper of the
Université Laval in Quebec, Canada gives an overview of CP and Combinatorial
Optimization, based on the following nine chapters:

  1. 1.

Introduction (54 slides)

  2. 2.

Search and Filtering (87 slides)

  3. 3.

Solver Design (44 slides)

  4. 4.

Filtering for Arithmetic Constraints (55 slides)

  5. 5.

Tractable Sub-classes (59 slides)

  6. 6.

Search Strategy (29 slides)

  7. 7.

Max Flow (87 slides)

  8. 8.

Linear Programming (131 slides)

  9. 9.

Conclusion (12 slides)

This course is more focused on the problem solving aspect of CP, and does not
discuss modelling or provide application examples.

###  4.5 Modelling for Combinatorial Optimization

The course ”Modelling for Combinatorial Optimisation” by Pierre Flener at
Uppsala University in Sweden consists of 8 modules, and is, in itself, part of
a longer course on ”Combinatorial Optimisation and Constraint Programming”.
The topics covered are

  1. 1.

Introduction (102 slides)

  2. 2.

Basic Modelling (61 slides)

  3. 3.

Constraint Predicates(53 slides)

  4. 4.

Modelling (22 slides)

  5. 5.

Symmetry (45 slides)

  6. 6.

Case Studies (34 slides)

  7. 7.

Solving Technologies (74 slides)

  8. 8.

Inference and Search (46 slides)

The course uses MiniZinc and different back-end solvers to present the
different concepts.

The longer course ”Combinatorial Optimisation and Constraint Programming”
extends the modelling course with on-site teaching of the material covered in
the MiniCP MOOC[13, 14] listed in Section 5.

###  4.6 Constraint Programming: Star Wars Edition

The course ”Constraint Programming: Star Wars Edition” by Pascal Van
Hentenryck and Tejas Santanam at Georgia Tech is a Star Wars-themed one-
semester online course for both undergraduate and graduate students that is a
modelling-focused course comprised of lecture videos, synchronous review
sessions, and modeling project assignments. The course is a longer form course
where each subtopic merits dozens of slides or hours of instruction and
review. The topics covered in the course are listed below, and further
information on the course can be found in the associated submission to The
Workshop on Teaching Constraint Programming 2023 [45, 46].

  1. 1.

Basic Concepts

     * •

Getting started

     * •

Basic concepts I

     * •

Basic concepts II

     * •

OPL Primer

  2. 2.

Elements of Constraint Programming

     * •

Reified constraints

     * •

Optimization

     * •

Expressions

  3. 3.

Theoretical Foundation

     * •

Computational Model

  4. 4.

Global Constraints

     * •

The element constraint

     * •

The table constraint

     * •

Combinatorial Constraints

     * •

The pack constraint

     * •

The circuit constraint

     * •

The lex constraints

  5. 5.

Modeling in Constraint Programming

     * •

Symmetry breaking

     * •

Subexpression elimination

     * •

Redundant constraints I

     * •

Redundant constraints II

  6. 6.

Search in Constraint Programming

     * •

Search tree and Impact

     * •

Restart and nogoods

  7. 7.

Implementation of Constraint Programming

     * •

Packing

     * •

AllDifferrent

     * •

NoOverlap

  8. 8.

Scheduling in Constraint Programming

     * •

Interval variables and noOverlap

     * •

The Sequence Constraints

     * •

Cumulative Constraints

     * •

The House Problem II

     * •

The House Problem III

     * •

The Perfect Square Problem

     * •

State Constraints

     * •

The Trolley Application

     * •

Optional Activities

     * •

Standard Scheduling Problems

     * •

Calendars

  9. 9.

Advanced Topics

     * •

Large neighborhood search

     * •

Scripting models

     * •

Routing

     * •

CP in Python

  10. 10.

Implementation in MiniCP

     * •

Semantics of CP

     * •

Operational Model of CP

     * •

Inference

     * •

Search

     * •

Advanced Inference

     * •

Advanced Search

##  5 Books

Table 4 gives an overview of books that were or are currently by used in
teaching Constraint Programming444Items in gray: I currently do not have a
hard copy of this book to validate some entries. Some of the entries are not
intended as textbooks, they are either, like [20], based on a PhD thesis, or
can be seen, like [26], as research monographs. But their content makes them
suitable as a source of examples, or descriptions of constraints or
algorithms, for courses on CP. The ”Handbook of Constraint Programming” [43]
was also mentioned as a reference by some of the survey participants, it
consists of a series of chapters describing the state of research at time of
publication, 2007.

The table gives the authors and title of the book, the year the book was
published, and the number of pages. Two of the books ([40] and [44]) are
general introductions to Artificial Intelligence, we also list. the length of
the chapters on Constraint Satisfaction. While the majority of books are
written in English, there are a number of French books, and one book written
in German. The English version of [38] is a translation from a Polish
original. We are not aware of books written, or translated, in other
languages. We also list the CP system used in each of the books, some entries
do not use an actual system in their description, while only one [6] has
examples using multiple systems. We tried to classify the intended audience of
the book, using information given in the books themselves, the classification
used is

U

undergraduate students

UU

advanced undergraduates

G

graduate students

R

researchers

M

masters programs

Finally, some of the books contain exercises, some even with solutions, which
are particularly helpful for self-study.

1.3  Author Title Year Pages Language CP System Audience Topics Exercises P
Van Hentenryck Constraint satisfaction in logic programming[20] 1989 224
English CHIP[15] - FD no F. Fages Programmation logique par contraintes[17]
1996 192 French GNU Prolog U Prolog, FD yes K. Marriott, P. Stuckey
Programming with Constraints[35] 1998 467 English CLP(R)[27] UU CLP(R) yes P.
Van Hentenryck The OPL Optimization Programming Language[21] 1999 254 English
OPL[22] - FD no J. Hooker Logic-Based Methods for Optimization[25] 2000 495
English - R, G FD, MIP no K. Apt Principles of Constraint Programming[3] 2003
407 English - UU Prolog, FD yes R. Dechter Constraint processing[12] 2003 481
English - ??? CSP ??? T. Frühwirth, S. Abdennadher Essentials of constraint
programming[18] 2003 156 English CHR G,R FD, CHR no K. Apt, M. Wallace
Constraint Logic Programming using ECLiPSe [4] 2007 329 English ECLiPSe[47]
UU,G Prolog, FD yes J. Hooker Integrated Methods for Optimization[26] 2007 486
English - R, G FD, MIP yes P. Hofstedt, A. Wolf Einführung in die Constraint-
Programmierung[24] 2007 388 German [l]TURTLE[19] firstcs[59] M FD yes D.
Poole, A. Mackworth Artificial Intelligence - Foundations of Computational
Agents[40] 2010 [r]900 (CSP ???) English - UU, G CSP yes C. Lecoutre
Constraint Networks: Targeting Simplicity for Techniques and Algorithms[29]
2013 320 English ??? ??? CSP, FD ??? A. Niederlinski A Gentle Guide to
Constraint Logic Programming via ECLiPSe[38] 2014 509 English ECLiPSe[47] U
Prolog, FD yes E. Tsang Foundations of Constraint Satisfaction: The Classic
Text[56] 2014 444 English ??? ??? CSP ??? N. Zhou, H. Kjellerstrand, J.
Fruhman Constraint Solving and Planning with Picat[61] 2015 140 English
Picat[60] U FD yes E. Bourreau, M. Gondran, P. Lacomme, M. Vinot De la
programmation linéaire à la programmation par contraintes[6] 2019 348 French
[l]Gusek CPLEX GLPK Choco-solver[42] M FD, MIP no E. Bourreau, M. Gondran, P.
Lacomme, M. Vinot Programmation par Contraintes[7] 2020 232 French Choco-
solver[42] M FD no S. Russell, P. Norvig Artificial Intelligence: A Modern
Approach (4th Edition)[44] 2020 [r]1115 (CSP 28) English - U CSP, FD no M.
Wallace Building Decision Support Systems - using MiniZinc[57] 2020 224
English MiniZinc[37] G FD, MIP, SAT yes

Table 4: Books for Learning Constraint Programming

##  6 Video Courses

Table 5 lists historical and current video courses on Constraint Programming.
Where available, a link to the course itself is provided. We also show
references describing the courses, the year the course was first made
available, the language the course material is presented in, and the CP system
that is used in the course. Finally, the length of the course is provided,
either as the length of the video itself, or the length of the course
expressed in hours, as stated by the course providers.

Table 5: Video Courses

Authors |  Title | Year | Language | CP System | Length
---|---|---|---|---|---
M. Dincbas, H. Simonis |  CHIP (Part I and II) [16] | 1989 | English |  CHIP[15] | 2 hours
C. Solnon |  Cours de Programmation Par Contraintes[54, 55] | 2003 | French |  |
H. Simonis |  ECLiPSe ELearning Course[49] | 2009 | English |  ECLiPSe[47] | 22 Lectures
J. Lee, P. Stuckey |  Basic Modeling for Discrete Optimization[10, 34, 33] | 2019 | English, Mandarin |  MiniZinc[37] | 27 hours
|  Advanced Modeling for Discrete Optimization | 2019 | English, Mandarin |  MiniZinc[37] | 46 hours
|  Solving Algorithms for Discrete Optimization | 2019 | English, Mandarin |  MiniZinc[37] | 22 hours
P. Schaus, L. Michel, P.Van Hentenryck |  LouvainX: Constraint Programming[13, 14] | 2023 | English |  MiniCP[36] |  14 weeks 6-8 hours per week

##  7 Articles

A Workshop on Teaching Constraint Programming was run at CP 2015, but the
proceedings of the workshop do no longer seem to be available on-line. Patrick
Prosser organized the workshop, he also gave an invited talk at CP 2014[41].

The Workshop on Teaching Constraint Programming 2023 at the CP 2023 conference
in Toronto had six submissions [31, 45, 11, 8, 2, 13, 46, 14], an invited talk
by Peter Stuckey and an overview presentation. The current paper is an
extended version of that overview.

There has also been exploration into how people approach CP which would be
useful to understand when trying to teach the subject. [23]

##  8 Tutorials

The tutorials covered in this section are shorter presentations, intended to
give an overview of Constraint Programming, its applications or one of its
major research topics. They can be presented as videos, and/or as slide sets.
In Table 6 we show the authors, and the title of the tutorial, together with a
link to an on-line version. We list the year the tutorial was made, the
language it is presented in, and the CP system used. We differentiate between
tutorials given as slide sets and videos. For the slides sets, we show the
number of slides, for the videos the length of the video.

Every year, the Association for Constraint Programming (ACP) organizes a
Summer School on specific Constraint Programming topics. A list of the Summer
Schools and the topics covered is presented at ACP Summer Schools. In some
years, the lectures of the Summer School are made available outside the
school, for example for the 2023 Summer School on Constraint Programming and
Machine Learning, all lectures are available on YouTube 2023 ACP Summer School
YouTube Channel.

Table 6: Tutorials

Authors |  Title | Year | Language | CP System | Format | Length
---|---|---|---|---|---|---
K. Kuchcinski |  Constraint Programming in Embedded System Design | 2010 | English |  MiniZinc [37], JaCoB [28] | Slides | 32 slides
H. Simonis |  Optimization Applications | 2023 | English | various | Slides | 132 slides
H. Simonis |  Logistics | 2022 | English | various | Slides | 79 slides
C. Beck |  Supply Chain Optimization: An Operations Research Perspective | 2021 | English |  | Video | 56:23 min
H. Simonis, G. Tack |  Visualization for Constraint Programming | 2022 | English |  MiniZinc [37], others | Video | 74:39 min
H. Simonis |  Constraint Programming Methodology | 2018 | English | n/a | Slides | 36 Slides

##  9 Other Material

Gene Freuder maintains a collection of resources about Constraint Programming.
This includes links to courses, tutorial, books and other teaching material.

The constraint group at the Uppsala University in Sweden maintains a list of
resources on constraint related topics.

The Global Constraint Catalog [5] provides a very comprehensive description of
global constraints, but also contains some exercises that can be used for
teaching CP. These exercises fall into three categories, modelling, filtering
techniques and specific global constraints (alldifferent, diffn, cumulative,
cycle, element, and others).

##  10 CP Course Formats

In the survey, and the other sections of this paper, available material and
what is currently missing has been identified. This next section considers
course formats to fill different niches for various audiences, and which
topics would be useful. The hope is that these formats can lead to sample
curricula and shared material sets.

So far we have identified five possible course variants.

###  10.1 One-Hour Overview

This describes a short one-hour overview of what CP is and what it is good
for. The audience would be students of different program types, but possibly
also the general public. This should be relatively easy to achieve, and could
be the first shared material set to be produced. Suggested topics for a one-
off short session would be:

  * •

Examples of real-world problems solved with CP

  * •

Description of the main underpinnings of CP, including branch-and-prune and
constraint propagation

  * •

Comparison of CP versus MIP

  * •

Example of how to construct a CP model for a small problem such as map
coloring

###  10.2 Short Course

This course would be used inside a more general course (Logic Programming,
Declarative programming, AI, Optimization, specific application areas), and
would give an idea of the overall concepts used in CP, as well as showing some
case studies highlighting success stories. We will need to identify how much
time is available for the CP part, and what background knowledge can be
assumed.

###  10.3 Modelling Course

This would be a course that focuses on modelling skills, but skips deeper
explanations of solving technology. It would be useful to still include a
high-level explanation of how the CP system actually works, and why that
results in limits of the problem sizes that can be handled.

###  10.4 Tools and Techniques

This would be a course that focuses on different technologies to solve CP
problems (FD, SAT, SMT, MIP, MDD, CBLS), and which explains in principle how
the reasoning inside the solver works. It would be nice if the course would
also explain why some methods work best for some problems, and fail for
others. This could be perhaps split into independent segments for each
technology?

An possible alternative would be a course describing different academic and
commercial tools for CP. This might in particular be of interest for
practitioners, especially if the strengths and limitations of different tools
for different application domains are clearly delineated.

###  10.5 Algorithms and Constraints

Many global constraints rely on specific algorithms to perform their
reasoning, like bipartite matching or max-flow for alldifferent and
cardinality constraints. This is largely independent of the actual constraint
solver used, the algorithm is called at some point to deduce the possible
propagation. An interesting course would present major global constraints with
the mechanisms used in their reasoning, perhaps extended by an example of the
use of the constraint is a real-world application. This is different from a
solver design course, where the focus is on the overall representation of the
constraints and variables, and their generic interaction.

The ”Graphs and Networks” course described in Section 4.3 could form the basis
of such a course, using a selection of global constraints from [5]. The
”ECLiPSe Elearning Course” described in Section 4.1 uses the format of linking
a specific application with the introduction of the global constraints
required to model the problem, and using visualization to show how the
constraint propagation allows to solve the problem.

###  10.6 Solver Course

This course explains how to design and build a solver for a specific
constraint technology, most likely using finite domain reasoning. This course
is intended for Computer Science students that need to know how a solver
operates, and that should get some experience in writing code and running
performance test experiments on a complex system.

This content might already be covered by the MiniCP [13, 14] course.

##  11 Conclusions

In this paper we have presented the results of a survey on Teaching Constraint
Programming, which we ran as part of the Workshop on Teaching Constraint
Programming at CP 2023 in Toronto. We have explained the motivation and
methodology used to the survey, and described the questions that we included
in the questionnaire. We have presented the detailed answers for the
questions, and performed a detailed analysis to understand what material is
currently available and which topics are currently not well covered. We have
also listed books, video courses, and course material collection that show how
different aspects of CP are currently taught. Finally, we have briefly
discussed which courses might be developed in the future, and which specific
areas should be explored as a priority.

The goal of this paper and the hope is that discussions on teaching CP can be
started and lead to the widespread open-source sharing of materials, course
styles, and ideas to everyone from those teaching CP for the first time or to
experienced CP educators. Any gaps in coverage within this paper is meant to
illustrate a future opportunity rather than a blind spot.

This paper is also focused on courses in the academic sphere, though there is
certainly merit in exploring CP use and education in industry. Unfortunately,
the authors were not privy to complete information about CP education in
industry. Despite that, CP is used today in industry for applications ranging
from manufacturing to autonomous vehicles. A potential future area of
exploration is the integration of CP education with industry to provide
application-based projects that can serve to motivate students and increase
job opporunities within CP in industry.

It also remains to be seen the impact that generative AI tools will have on CP
education. As the CP community plans and designs curricula, exercises, and
exams going forward, it is vital to strike the balance between a student
learning the content and concepts with the help of generative AI tools like
ChatGPT or a student mindlessly letting generative AI tools do their
schoolwork for them.

Ultimately, the path toward continued growth for the CP community stems from
the development of further CP practitioners and educators via CP courses. This
paper attempts to serve as a snapshot and survey of the methods and resources
in the field to make it easier to plan and teach CP or develop resources to
that end.

## Acknowledgment

We want to thank all participants in the survey, and the authors and attendees
of the WTCP23 workshop for their valuable view points and discussions. Special
thanks to the Association for Constraint Programming and its president, David
Bergman, for supporting this initiative.

## References

  * [1] Özgür Akgün, Alan M. Frisch, Ian P. Gent, Christopher Jefferson, Ian Miguel, and Peter Nightingale.  Conjure: Automatic generation of constraint models from problem specifications (extended abstract).  In Proceedings of the Thirty-Second International Joint Conference on Artificial Intelligence, IJCAI 2023, 19th-25th August 2023, Macao, SAR, China, pages 6833–6838. ijcai.org, 2023.
  * [2] Josep Alos, Carlos Ansótegui, Jose María Salvia, and Eduard Torres Montiel.  OptiLog for education.  In Tejas Santanam and Helmut Simonis, editors, Workshop on Teaching Constraint Programming (WTCP2023), Toronto, Canada, August 2023.
  * [3] Krzysztof R. Apt.  Principles of constraint programming.  Cambridge University Press, 2003.
  * [4] Krzysztof R. Apt and Mark Wallace.  Constraint logic programming using ECLiPSe.  Cambridge University Press, 2007.
  * [5] Nicolas Beldiceanu, Mats Carlsson, Sophie Demassey, and Thierry Petit.  Global constraint catalogue: Past, present and future.  Constraints An Int. J., 12(1):21–62, 2007.
  * [6] Eric Bourreau, Matthieu Gondran, Philippe Lacomme, and Marina Vinot.  De la programmation linéaire à la programmation par contraintes.  ellipses, Paris, France, 2019.  in French.
  * [7] Eric Bourreau, Matthieu Gondran, Philippe Lacomme, and Marina Vinot.  Programmation par Contraintes.  ellipses, Paris, France, 2020.  in French.
  * [8] Marc Cané, Jordi Coll, Marc Rojo, and Mateu Villaret.  SAT-IT: the interactive SAT tracer.  In Tejas Santanam and Helmut Simonis, editors, Workshop on Teaching Constraint Programming (WTCP2023), Toronto, Canada, August 2023.
  * [9] Mats Carlsson and Per Mildner.  SICStus Prolog – the first 25 years, 2010.
  * [10] Mavis Chan, Cecilia Chun, Holly Fung, Jimmy H. M. Lee, and Peter J. Stuckey.  Teaching constraint programming using fable-based learning.  In The Thirty-Fourth AAAI Conference on Artificial Intelligence, AAAI 2020, The Thirty-Second Innovative Applications of Artificial Intelligence Conference, IAAI 2020, The Tenth AAAI Symposium on Educational Advances in Artificial Intelligence, EAAI 2020, New York, NY, USA, February 7-12, 2020, pages 13366–13373. AAAI Press, 2020.
  * [11] Janet Choi, Barry O’Sullivan, and Helmut Simonis.  Teaching constraint programming in the SFI CRT-AI program.  In Tejas Santanam and Helmut Simonis, editors, Workshop on Teaching Constraint Programming (WTCP2023), Toronto, Canada, August 2023.
  * [12] Rina Dechter.  Constraint processing.  Elsevier Morgan Kaufmann, 2003.
  * [13] Augustin Delecluse, Guillaume Derval, Laurent Michel, Pierre Schaus, and Pascal Van Hentenryck.  A review of the constraint programming MOOC on EdX.  In Tejas Santanam and Helmut Simonis, editors, Workshop on Teaching Constraint Programming (WTCP2023), Toronto, Canada, August 2023.
  * [14] Augustin Delecluse, Guillaume Derval, Laurent Michel, Pierre Schaus, and Pascal Van Hentenryck.  A review of the constraint programming mooc on edx.  In Workshop on Teaching Constraint Programming, WTCP 2023, volume 1, page 14, 2023.
  * [15] Mehmet Dincbas, Pascal Van Hentenryck, Helmut Simonis, Abderrahmane Aggoun, Thomas Graf, and Françoise Berthier.  The constraint logic programming language CHIP.  In Proceedings of the International Conference on Fifth Generation Computer Systems, FGCS 1988, Tokyo, Japan, November 28-December 2, 1988, pages 693–702. OHMSHA Ltd. Tokyo and Springer-Verlag, 1988.
  * [16] Mehmet Dincbas and Helmut Simonis.  CHIP (part i and ii), 1989.  Video course for EuroPACE.
  * [17] Francois Fages.  Programmation logique par contraintes.  ellipses, Paris, France, 1998.  in French.
  * [18] Thom W. Frühwirth and Slim Abdennadher.  Essentials of constraint programming.  Cognitive Technologies. Springer, 2003.
  * [19] Martin Grabmüller and Petra Hofstedt.  Turtle: A constraint imperative programming language.  In Frans Coenen, Alun Preece, and Ann Macintosh, editors, Research and Development in Intelligent Systems XX, pages 185–198, London, 2004\. Springer London.
  * [20] Pascal Van Hentenryck.  Constraint satisfaction in logic programming.  Logic programming. MIT Press, 1989.
  * [21] Pascal Van Hentenryck.  The OPL Optimization Programming Language.  MIT Press, 1999.
  * [22] Pascal Van Hentenryck.  Constraint and integer programming in OPL.  INFORMS J. Comput., 14(4):345–372, 2002.
  * [23] Ruth Hoffmann, Xu Zhu, Özgür Akgün, and Miguel A. Nacenta.  Understanding How People Approach Constraint Modelling and Solving.  In Christine Solnon, editor, 28th International Conference on Principles and Practice of Constraint Programming (CP 2022), volume 235 of Leibniz International Proceedings in Informatics (LIPIcs), pages 28:1–28:18, Dagstuhl, Germany, 2022. Schloss Dagstuhl – Leibniz-Zentrum für Informatik.
  * [24] Petra Hofstedt and Armin Wolf.  Einführung in die Constraint-Programmierung - Grundlagen, Methoden, Sprachen, Anwendungen.  eXamen.press. Springer, 2007.  in German.
  * [25] John Hooker.  Logic-Based Methods for Optimization: Combining Optimization and Constraint Satisfaction.  Wiley, 2000.
  * [26] John N. Hooker.  Integrated methods for optimization, volume 100 of International series in operations research and management science.  Springer, 2007.
  * [27] Joxan Jaffar, Spiro Michaylov, Peter J. Stuckey, and Roland H. C. Yap.  The CLP(R) language and system: an overview.  In Compcon Spring ’91, San Francisco, California, USA, February 25 - March 1, 1991. Digest of Papers, pages 376–381. IEEE Computer Society, 1991.
  * [28] Kuchcinski, Krzysztof and Szymanek, Radoslaw.  JaCoP - Java Constraint Programming Solver, 2013.
  * [29] Christophe Lecoutre.  Constraint Networks: Targeting Simplicity for Techniques and Algorithms.  Wiley, 2013.
  * [30] Christophe Lecoutre.  Ace, a generic constraint solver.  CoRR, abs/2302.05405, 2023.
  * [31] Christophe Lecoutre.  Teaching constraint programming while using PyCSP3, ACE and Jupyter notebook.  In Tejas Santanam and Helmut Simonis, editors, Workshop on Teaching Constraint Programming (WTCP2023), Toronto, Canada, August 2023.
  * [32] Christophe Lecoutre and Nicolas Szczepanski.  PYCSP3: modeling combinatorial constrained problems in python.  CoRR, abs/2009.00326, 2020.
  * [33] Jimmy H. M. Lee.  From MOOC to SPOC: fable-based learning.  In Richard Chen Li, Simon K. S. Cheung, Chiaki Iwasaki, Lam For Kwok, and Makoto Kageto, editors, Blended Learning: Re-thinking and Re-defining the Learning Process. - 14th International Conference, ICBL 2021, Nagoya, Japan, August 10-13, 2021, Proceedings, volume 12830 of Lecture Notes in Computer Science, pages 16–25. Springer, 2021.
  * [34] Jimmy H. M. Lee.  A tale of two cities: Teaching CP with story-telling (invited talk).  In Roland H. C. Yap, editor, 29th International Conference on Principles and Practice of Constraint Programming, CP 2023, August 27-31, 2023, Toronto, Canada, volume 280 of LIPIcs, pages 2:1–2:1. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2023.
  * [35] Kim Marriott and Peter Stuckey.  Programming with Constraints.  MIT Press, 1998.
  * [36] L. Michel, P. Schaus, and P. Van Hentenryck.  MiniCP: a lightweight solver for constraint programming.  Mathematical Programming Computation, 13(1):133–184, 2021.
  * [37] Nicholas Nethercote, Peter J. Stuckey, Ralph Becket, Sebastian Brand, Gregory J. Duck, and Guido Tack.  MiniZinc: Towards a standard CP modelling language.  In Christian Bessiere, editor, Principles and Practice of Constraint Programming - CP 2007, 13th International Conference, CP 2007, Providence, RI, USA, September 23-27, 2007, Proceedings, volume 4741 of Lecture Notes in Computer Science, pages 529–543. Springer, 2007.
  * [38] Antoni Niederlinski.  A Gentle Guide to Constraint Logic Programming via ECLiPSe.  Economic University in Katowice, 3rd edition, 2014.  Translated from Polish.
  * [39] Peter Nightingale.  Savile row manual.  CoRR, abs/2201.03472, 2022.
  * [40] David Poole and Alan K. Mackworth.  Artificial Intelligence - Foundations of Computational Agents.  Cambridge University Press, 2010.
  * [41] Patrick Prosser.  Teaching constraint programming.  In Barry O’Sullivan, editor, Principles and Practice of Constraint Programming - 20th International Conference, CP 2014, Lyon, France, September 8-12, 2014. Proceedings, volume 8656 of Lecture Notes in Computer Science, page 3. Springer, 2014.
  * [42] Charles Prud’homme and Jean-Guillaume Fages.  Choco-solver: A java library for constraint programming.  J. Open Source Softw., 7(78):4708, 2022.
  * [43] Francesca Rossi, Peter van Beek, and Toby Walsh, editors.  Handbook of Constraint Programming, volume 2 of Foundations of Artificial Intelligence.  Elsevier, 2006.
  * [44] Stuart Russell and Peter Norvig.  Artificial Intelligence: A Modern Approach (4th Edition).  Pearson, 2020.
  * [45] Tejas Santanam and Pascal Van Hentenryck.  Modern constraint programming education: Lessons for the future.  In Tejas Santanam and Helmut Simonis, editors, Workshop on Teaching Constraint Programming (WTCP2023), Toronto, Canada, August 2023.
  * [46] Tejas Santanam and Pascal Van Hentenryck.  Modern constraint programming education: Lessons for the future.  arXiv preprint arXiv:2306.13676, 2023.
  * [47] Joachim Schimpf and Kish Shen.  ECL${}^{\mbox{i}}$PS${}^{\mbox{e}}$ \- from LP to CLP.  Theory Pract. Log. Program., 12(1-2):127–156, 2012.
  * [48] Christian Schulte, Guido Tack, and Mikael Z. Lagerkvist.  Modeling and programming with Gecode, 2010.
  * [49] Helmut Simonis.  Lessons learned from developing an on-line constraint programming course.  In Patrick Prosser, editor, WTCP 2015 - Workshop on Teaching Constraint Programming, Cork, Ireland, August 2015.
  * [50] Helmut Simonis, editor.  Principles and Practice of Constraint Programming - 26th International Conference, CP 2020, Louvain-la-Neuve, Belgium, September 7-11, 2020, Proceedings, volume 12333 of Lecture Notes in Computer Science. Springer, 2020.
  * [51] Helmut Simonis, Paul Davern, Jacob Feldman, Deepak Mehta, Luis Quesada, and Mats Carlsson.  A generic visualization platform for CP.  In David Cohen, editor, Principles and Practice of Constraint Programming - CP 2010 - 16th International Conference, CP 2010, St. Andrews, Scotland, UK, September 6-10, 2010. Proceedings, volume 6308 of Lecture Notes in Computer Science, pages 460–474. Springer, 2010.
  * [52] Helmut Simonis and Barry O’Sullivan.  Search strategies for rectangle packing.  In Peter J. Stuckey, editor, Principles and Practice of Constraint Programming, 14th International Conference, CP 2008, Sydney, Australia, September 14-18, 2008. Proceedings, volume 5202 of Lecture Notes in Computer Science, pages 52–66. Springer, 2008.
  * [53] Helmut Simonis and Barry O’Sullivan.  Almost square packing.  In Tobias Achterberg and J. Christopher Beck, editors, Integration of AI and OR Techniques in Constraint Programming for Combinatorial Optimization Problems - 8th International Conference, CPAIOR 2011, Berlin, Germany, May 23-27, 2011. Proceedings, volume 6697 of Lecture Notes in Computer Science, pages 196–209. Springer, 2011.
  * [54] Christine Solnon.  Un cours ”électronique” sur la programmation par contraintes.  Tech. Sci. Informatiques, 22(1):77–80, 2003.
  * [55] Christine Solnon.  Un cours ”électronique” sur la programmation par contraintes.  In Mireille Ducassé, editor, Journées Francophones de Programmation en Logique avec Contraintes (JFPLC 2003), Amiens, France, du 17 au 19 Juin 2003, pages 77–80. Hermes/Lavoisier, 2003.
  * [56] Edward Tsang.  Foundations of Constraint Satisfaction.  Books on Demand, 2014.
  * [57] Mark Wallace.  Building Decision Support Systems - using MiniZinc.  Springer, 2020.
  * [58] Jan Wielemaker, Tom Schrijvers, Markus Triska, and Torbjörn Lager.  SWI-Prolog.  Theory and Practice of Logic Programming, 12(1-2):67–96, 2012.
  * [59] Armin Wolf.  firstcs-new aspects on combining constraint programming with object-orientation in java.  KI - Künstliche Intelligenz, 26(1):55–60, 2012.
  * [60] Neng-Fa Zhou.  Programming in Picat.  In José Júlio Alferes, Leopoldo E. Bertossi, Guido Governatori, Paul Fodor, and Dumitru Roman, editors, Rule Technologies. Research, Tools, and Applications - 10th International Symposium, RuleML 2016, Stony Brook, NY, USA, July 6-9, 2016. Proceedings, volume 9718 of Lecture Notes in Computer Science, pages 3–18. Springer, 2016.
  * [61] Neng-Fa Zhou, Hkan Kjellerstrand, and Jonathan Fruhman.  Constraint Solving and Planning with Picat.  Springer Briefs in Intelligent Systems. Springer, 2015.

##  Appendix A More Survey Results

Given the rise of large language models in recent years, we asked about
positive or negative experiences with such tools in the courses. The majority
of replies answered ”No”, or ”Not Yet”, and some participants were confused by
the question.

YesNoNot yetHuh?$0$$5$$10$$15$$4$$18$$12$$3$Count Figure 17: Have you seen any
impact of Large Language Models (LLM)?

The ”Yes” answers show that the impact does not have to be negative, but that
the course will probably have to adapt to avoid cheating by students in their
assignments.

  * •

Added material to course to show potential benefits

  * •

Students use it to generate part of their coursework

  * •

Some assignments can be solved by using ChatGPT

  * •

A student found a bug in her program by asking ChatGPT for help