diff --git a/Course.md b/Course.md
deleted file mode 100644
index 5e92d677669113e1f4ebf5f7c9ba0d24a9233904..0000000000000000000000000000000000000000
--- a/Course.md
+++ /dev/null
@@ -1,760 +0,0 @@
----
-title: IST-4-JAV Java Programming
-subtitle: Course
-author: Alice BRENON `<alice.brenon@liris.cnrs.fr>`
-documentclass: report
-paper: a4
-numbersections: true
-header-includes:
- \usepackage{graphicx}
- \usepackage{hyperref}
- \usepackage{color}
- \definecolor{mauve}{RGB}{103, 58, 183}
- \hypersetup{
- colorlinks,
- linkcolor = black,
- urlcolor = mauve
- }
----
-
-# Introduction — programming and Java
-
-Java is a statically-typed, object-oriented, programming language designed to
-write programs which are compiled to a bytecode for a virtual machine. Before we
-start learning the Java language itself, let us think about programming in
-general and define the technical terms in the previous sentence.
-
-## Architecture
-
-## Types
-
-## Object-oriented
-
-## Formulas and computations
-
-Programming and computers in general often tend to be associated with
-mathematics because both those fields use a lot of numbers and symbols. However
-they differ on key aspects. In maths, there is no time and no space. Mathematics
-exist outside any physical considerations. We define objects[^objects] and they just
-exist, not "immediately" but without even any notion of time. We don't "travel"
-through infinite sets, we simply consider any part we want. We can write down a
-formula, however complex, and as long as it makes sense it both defines a new
-object and assigns it its value.
-
-[^objects]: while the term "object" has a very precise meaning in the context of
- Java and "object-oriented" programming languages in general, we will have to
- use it throughout this introduction to give the idea of how programming is
- about modeling… well, "things", that we will smugly call "objects". Actual
- Java "objects" will be defined properly in the next chapter.
-
-But such a symbolic definition is of no use when actual values are needed in a
-concrete application like engineering or statistics. Converting those formulas
-into actionable data is an entirely different matter that doesn't always rely on
-the same kind of skills : there starts the realm of computing where notions like
-efficiency start to make sense. There may be several paths to get the result's
-digits, not all of which are necessarily equivalent : writing a calculation one
-way or another can take more or less time, and use more or less space (think of
-the number of intermediate steps you have to write down, or the difficulty to
-memorize them if you're doing it mentally).
-
-Now despite a little optimization here and there to calculate more efficiently,
-the rules one needs to apply to get the results are entirely objective and
-pre-defined by our numeral system. No choice can be made to change the result.
-
-This probably explains at least partly why many people find calculation tedious
-and boring, but it is actually a very good property for several reasons.
-Obviously, this objectivity allows people to agree on the actual results, but
-there's more. Those rules aren't tedious to apply because they are too
-complicated, on the contrary they are tedious because they are so simple. The
-difficulty in doing a calculation isn't in figuring out what two digits make
-when summed together, it lies in the repetition of many such easy steps. This
-is crucial to be able to verify each step and find errors. The most important
-property of this system, however, is possibly that its ability to define the
-result of an infinite number of calculations with only a (small) set of rules.
-With this system, anyone given enough time is able to compute the sum or the
-product of any two arbitrarily large numbers, that one has never ever seen
-before.
-
-## Models (or "you were already programming this whole time")
-
-This example is very precious in the way it captures a fundamental part of
-programming : evaluating formulas to get a meaningful result for humans requires
-to *model* the entities involved in order to be able to derive the expected
-result by applying a set of *simple* and *objective* rules. In this particular
-exemple, the entities we consider are numbers, which may seem natural and
-intuitive at first but are at the same time quite abstract and hard to
-conceptualize in themselves without the use of digits. This is why various
-numeral systems have been devised as so many *representations* of those
-concepts. Indeed we are so used to visualizing integers as a sequence of digits
-that you may not even have thought about the fact that an integer exists in
-itself, outside of its base-10 writing which is only one way (among many others)
-to represent it.
-
-Note that these representations work both ways : given a number, you are able to
-*encode* it into a string of digits, but conversely seeing a string of digits is
-enough for you to conceptualize the number it represents (you can *decode* it).
-
-- real useful concept : number
-- model : a string of digits
-- conversion between reality and model : numeral system
-- operations on the model : the arithmetic rules ("9 + 3 make 12, write 2, carry
- 1 and…")
-
-Though very simple here — so simple that it was hard at first to notice it's even
-there — this very process is the heart of programming. All that's ever been done
-with computers is this : defining a layer useful enough to solve a certain class
-of problems, and then encode more abstract problems on top of this layer to be
-able to solve them as well.
-
-A way to visualize this pattern is to build the following parallelogram :
-
-\begin{tabular}{l r}
-Want to solve a problem B about A ? &
-\parbox[c]{\hsize}{\includegraphics[height=60px]{graphs/parallelogram0.png}} \\
-Encode the problem in another space where it's easier &
-\parbox[c]{\hsize}{\includegraphics[height=60px]{graphs/parallelogram1.png}} \\
-Solve the problem there instead &
-\parbox[c]{\hsize}{\includegraphics[height=60px]{graphs/parallelogram2.png}} \\
-Decode the solution you found &
-\parbox[c]{\hsize}{\includegraphics[height=60px]{graphs/parallelogram3.png}} \\
-\end{tabular}
-
-### Calculators
-
-The abacus has been in use for more than four thousand years, has spread in many
-regions of the world and is still in use to this day, being able to perform
-[competitively](https://www.ee.ryerson.ca/~elf/abacus/abacus-contest.html)
-against electronic calculators. The arithmetic rules we mentioned above are so
-repetitive, tedious, "mechanical" that it was only natural to represent them by
-a physical mean.
-
-The first automatic calculator was invented by Blaise Pascal in 1642. It was a
-mechanical device which represented numbers by the positions of wheels moving
-according to the arithmetic rules applied to decimal digits. It pushed the idea
-of automation one step further compared to the abacus by removing the need to
-manually update the position of the "memory" holding the calculation state.
-
-In 1864, Charles Babbage developed an "analytical engine" which has then been
-studied and documented by Lady Ada Lovelace, who is credited for writing the
-first program in history as an illustration of the way the machine worked. The
-Analytical Engine moved yet another step forward by representing mathematical
-objects, such as polynoms, by numbers to be able to compute approximations of
-interesting functions (logarithms, trigonometric functions, etc.). The
-analytical engine had abstracted several key concepts that appear during
-computations, like the "memory" required to hold intermediate computation steps
-or the notion of "program", written on punched cards : designing a machine with
-more expressive power than a basic calculator required a language more complex
-that one button for each arithmetic operator to describe what was expected of
-it, and this language had to be readable by mechanical means.
-
-This shows that humans didn't wait for silicon to be able to automate
-calculations. But computers wouldn't have been very useful if they had been
-restricted to mathematical problems : like the Analytical Engine, Java and other
-modern programming languages are more than the language of expressions you've
-been punching into calculators in junior high-school and they are not limited to
-representing numbers, or rather, since electronic and mechanical devices can
-handle only numbers natively, they have ways to represent more complex data.
-
-### Anything is a number
-
-Indeed, if for instance numbers seem more than enough to model physics problems
-(think of the position or the mass of a body, its speed, etc.), problems in
-other fields may appear at first less straightforward to solve with numbers. We
-will see that numbers can do much though.
-
-History is full of events whose outcome was strongly influenced by the secrecy
-of strategic intelligence. For such purposes, spies, generals and children alike
-have created tables to convert letters into numbers and back in order to be able
-to encrypt their messages by applying mathematical operations on the coded
-versions. All encryption schemes in history weren't based on this approach but
-they were prominent enough for Cæsar's "ROT13" to be remembered over two
-thousand years later. These tables of characters assigning each an arbitrary
-code is the basis of what is now called a "character encoding" (like ASCII,
-ISO-8859, UTF-8…).
-
-But their clever tricks not only showed how numbers could help represent text,
-they contained the idea that a "large" object like a whole message could be
-sequenced into several "short" objects (letters) that could each be represented
-by numbers. While the operation wasn't explicited first, with humans manually
-decoding encrypted messages and deciding how long to *repeat* the same decoding
-operation on each *part* of the message, it isn't hard once a machine is
-involved to encode the information "is this a single unit ?" or "is this the
-begining of a sequence" (by, say, storing it in the first or last digit of each
-unit).
-
-Actually, there are at least two major strategies to represent sequences of
-objects, and this alternative is a common "landmark" spot on the learning
-route to C, a notable ancestor of Java. The first one is to directly store
-object after object, and to reserve a special value which no object can take to
-mark the end of the sequence. The other stores the length of the sequence at its
-begining, letting the machine know in advance how many objects it can expect to
-read. But in Java we won't have to concern ourselves with such questions since
-the language already provides a built-in way to represent sequences.
-
-Once we have sequences, the expressivity of numbers rises seriously. Encoding
-sequences of sequences, we have access to multi-dimensional objects such as
-pictures; storing different kinds of objects side by side (text, numbers,
-sequences, other objects…) we can describe more complex real-world concepts and
-start developing useful models that can do useful things for us (think, for
-instance, of the representation of a music track if you're trying to develop a
-music player : you'll probably need to store the actual sound data, but also its
-title, the name of the band, the title of the album, its duration, possibly the
-lyrics, etc.). All numbers.
-
-The above isn't of course a very precise blueprint for a general-purpose format
-to store binary data, but this rough sketch hopes to show a way in which very
-complex data can be represented by numbers, *while retaining some of its
-structure* so that useful things can be said on the actual real-world objects
-by considering their models only. The most important thing to remark here is
-that some objects have a natural direct representation as numbers while others
-need a little more work to be digitized. This distinction matters because it
-will have consequences on how both groups will be handled by programming
-languages in general and Java in particular.
-
-## Up to… the Java Machine
-
-### Architecture
-
-We noticed earlier that numbers themselves were too abstract to be handled
-directly and that numeral systems with digits and arithmetic rules were devised
-as a model that allowed to do calculations on them. But this model has a limit :
-a physical world full of upper bounds with finite space accessible in a finite
-time can only accomodate a finite number of digits.
-
-Likewise, practical computing devices from the abacus to the processor all have
-a fixed predefined number of digits and can't represent any number but only a
-finite subset of them. While each rod on an abacus can represent the ten digits
-we're used to, electronic circuits were designed to represent only two digits,
-0 and 1, hence favouring the use of a binary notation of numbers, that is, the
-base 2 over base 10. A "32-bit" processor has thus 32 (binary) digits to
-represent numbers, and a "64-bit" processor 64 digits, meaning that they can
-only represent respectively $2^{32}$ and $2^{64}$ different values, usually
-numbers from the sets $[0, 2^{n}-1]$ or $[-2^{n-1}, 2^{n-1}-1]$ for an n-bit
-processor.
-
-Such a set of bits of fixed length is called a *word* (and the number of bits it
-takes its *size*). When a carry occurring during a computation needs a new bit
-to be represented that exceeds the size, the physical device has no other option
-than to merely drop it, and "loop" over from 0. The same would happen if you had
-for instance an abacus with 5 rods, representing 99999, and you added 1Â :
-applying the rules, all '9' digits would shift to '0', but you couldn't carry
-the last '1' to a new rod. When this happens the device is said to *overflow*.
-
-Natively, the processor can only handle words, which means that the distinction
-we made earlier between what was immediately numbers and more complex data
-wasn't enough : actually, even numbers greater than the maximum value of a word
-are complex data to a processor and require a special encoding just like
-sequences. For us, it means that Java won't be able to handle a "small" integer
-and one of arbitrary size the same way and this is a key to understand why
-there are different types of numbers in programming languages.
-
-### Layers
-
-We already knew that handling complex objects would come at a cost, but we've
-just understood why even large integers would be just as painful to handle.
-You should be convinced by now that no one really wants to operate directly on
-their word representations. A complex representation of data requires more
-abstract ways to process it, while always relying on the same base layer in the
-end : the processor.
-
-Processors operate on numbers stored in registeres, some for input data and others
-to know the next instruction they should execute on those values. They are thus
-built with a certain number of predefined operations they can perform on input
-words. The size of their words as well as this set of *instructions* determines
-what is called the *architecture* of a processor.
-
-The first level of abstraction over the binary language of the processor was to
-name all these operations as well as the "places" where words could be entered
-(those are the *registers*) in order to be able to describe in a relatively
-simple text file what the processor was expected to do. These are the assembly
-languages, they follow processor instruction closely and only give clearer names
-to things to make programs more readable than actual binary code but one still
-has to manually put the values needed into the proper registers.
-
-The next big step was to introduce the notion of variables to free the
-programmer from the administrative work of loading and saving registers. This
-is a huge conceptual step because it enables one to refer to arbitrarily many
-objects at once just like in human languages. The price to pay for this power
-is the difficulty to name things, one of the hardest problems in programming.
-As we will see later in this course, great care should be taken in choosing
-names for objects, as poor names make bad code which is much worse than no code
-at all.
-
-Languages of this level, like ALGOL, originally developed in 1958, still
-describe algorithms as sequences of instructions to perform in a given order
-setting and modifying the values of these variables as they run. This is the
-core of the "imperative" approach, probably culminating in the C language, a
-successor which added a lot of expressivity by allowing to define data types and
-really start the modeling process we've been discussing all along.
-
-At this level of abstraction, code is regrouped into *procedures* or
-*functions* (some people don't make a difference and t they are indeed synonyms
-to a large extent but the distinction matters for Java) and they provide loops
-to ease the control of the flow of the program, by allowing to iterate on the
-values of a variable (in assembly, this was only possible by jumping to
-specific parts of the program after running a test on the value in a specific
-register).
-
-Java is yet a level higher in terms of abstraction as it is an object-oriented
-language : in addition to the definition of data structures like C, it allows
-to regroup functions operating on a given data structure and attach them
-tightly to it for clarity (and other benefits we will see later), as a metaphor
-of physical devices (think of a washing machine or a hi-fi system) which have
-programmed routines that can be triggered by pressing buttons. It also
-introduces the notion of packages and namespaces which are ways to separate
-cleanly independent parts of programs, avoiding name conflicts and misuse of
-internal states of implementations.
-
-### Compilers and interpreters
-
-Each new language introduces new abstractions whose semantics must eventually
-be described in terms of what can be run, that is, machine code. But there are
-two major strategies to actually perform this conversion from a higher-level
-language to a lower-level.
-
-One is to perform the translation once and produce code in the destination
-language, a process called *compilation*. This is conceptually the more simple
-and in the end the compiled code can be very optimized and close to what you
-would've written directly in the lower-level language. Once converted to machine
-code, you get an executable that you can simply run like any other program and
-that contains only the instructions needed for your purpose so it can be rather
-small.
-
-The other approach is to translate instructions on the fly by writing an
-*interpreter*Â : a sort of general purpose program which reads what to do during a
-given run from a *script* written in the abstract language defined by that
-interpreter. It is generally slower than compiled code because the instructions
-need to be understood and translated while the program is running. In addition
-to that, the interpreter itself is the actual program that gets executed by the
-processor, so it needs to be loaded in the memory, which has additional cost
-when the script is started. On the other hand, as they introduce an intermediate
-level, they are less tightly coupled to the underneath layer, which means that
-by porting the interpreter to a new platform (for example, a new architecture),
-you get all the scripts written for that interpreter to work, with no additional
-work if the interpreter really abstracts correctly from the layer it's
-implemented in (which is always more or less the case in practice).
-
-the translation
-
-
-doesn't have to go all the way down for each language. In fact, most languages
-are implemented in an existing lower-level language and not directly . If you set out to
-create a language you would probably want to define its semantic in term of
-assembly or even C, you wouldn't need to be able to convert its source code
-directly to machine code because it's easier to produce C and we already have
-tools to convert C code to a binary executable : the ones distributed to support
-
-C by one of its many implementations. There are two major strategies to actually
-perform this conversion from a higher-level language to a lower-level.
-
-Java combines a bit of both : it's a compiled language, but instead of compiling
-directly to machine code it compiles to an intermediate binary format containing
-instructions for a sort of interpreter, the *Java Machine* (this type of
-interpreter for binary code is more generally called a *virtual machine*).
-
-Our Java program will hence have a compiler, `javac`, to produce binary files
-(called *bytecode*) that are not directly executable but sorts of "binary
-scripts" for the `java` interpreter. It's usually a bit slower than a true
-executable but the bytecode is way more optimized than a textual script, and its
-strong selling point is the portability it provides : a Java program, once
-compiled, can be copied to any machine where the Java machine has been ported
-and run there ("Write Once Run Anywhere" was the slogan used by Sun Microsystem
-in advertisement material).
-
----
-
-\vspace{2cm}
-
-**Take away**
-
-So let's sum up the important ideas we've found thinking about computing.
-
-Programming is about developing models of problems to be able to solve them
-automatically. This is conceptually very similar to numeral systems used to
-perform calculations on numbers : a programming language plays the part of
-arithmetic, a numeral system with operators, that let one assemble programs, the
-equivalent of expressions, that can then be run automatically by a machine
-applying simple rules to get a result just like applying simple rules on the
-digits let one transform for instance a sum into the expected number.
-
-The architecture of today's computers implies that in the end, everything must
-be represented by a (small) number, but many levels of abstractions above the
-processor let one use many expressive and complex types of data, which will
-however have to be handled a little differently from the types directly
-translatable into numbers.
-
-The Java language is implemented as a compiler for a virtual machine : a program
-transforms textual source code into a set of instructions stored in a binary
-file, that can then be run by the virtual machine with no additional work on any
-platform where the virtual machine was ported.
-
-# The language
-
-Now that we got ourselves some notion of what we are actually doing while
-programming in Java, let's focus on the rules that describe what can be done in
-that language.
-
-As we will start writing actual snippets of Java code, we will use `this`
-special typography to mean that the text written in it is legit Java.
-
-## Data structures
-
-The introduction has (hopefully) shown that the core of programming is to build
-useful *models* of actual problems we want to solve. Doing so requires a toolbox
-to define those models : data structures.
-
-Contrary to what one could believe thinking of programs as "cooking recipe" for
-computers, an important part of a program is *describing* things instead of
-*doing* things. The following constructs might hence seem hard to understand,
-because they don't really achieve much in themselves. They are nonetheless as
-important as the next section and should be properly understood before
-attempting to write anything.
-
-Because it is easier to describe a set by giving examples of elements it
-contains, we will in this section present built-in Java types as well as valid
-*litterals* for each type, that is, atomic snippets of code that Java
-interprets as direct values.
-
-### "Numbers"
-
-The above remarks on architectures have taught us that the machines we use to
-program can only handle directly (a finite subset of) natural numbers. But those
-finite subset come in different flavours for different purposes :
-
-**boolean**
-
-The simplest piece of information that can be stored is a binary truth value :
-either `true` or `false`, as described in Boole's algebra. They are of course
-a lot shorter than a machine word and are hence obviously immediate values.
-
-**byte**
-
-While booleans are useful in Java programs along with
-[conditionals](#conditionals) to orient the execution of the program, they don't
-really exist outside the execution of programs because the smallest practical
-unit of storage is the `byte`, a field of 8 bits. This type covers values
-between
-
-- `-128` and
-- `127`
-
-but it is seldom used to represent actual numbers. It is usually found in code
-implementing binary protocols, reading raw binary data from files or network
-sockets.
-
-**int**
-
-Short for *integer*, `int` are just that : a truncated version of the set of
-natural numbers. Since Java was normalized in the 90s, at a time when 32-bit
-architecture dominated the market, they are of course 32-bit integers, the size
-of machine words at the time, to fit entirely in a processor register for the
-sake of efficiency.
-
-Values of this type can be created in programs by simply writing a string digit
-like we are used to, for instance on calculators. These are valid values :
-
-- `0`
-- `1`
-- `943`
-
-As all primitive number types, they can take positive or negative values, so
-
-- `-2`
-
-is valid too. Since we know they can go from $-2^{31}$ to $2^{31}-1$ it means
-that :
-
-- `-2147483648`
-- `2147483647`
-
-are valid too and are the bounds of the values for this type. Finally, Java
-supports notation in other bases : binary, octal and hexadecimal. Binary values
-are prefixed by "0b", octal only by a "0" (this is a frequent caveat, don't pad
-the numbers you write in a program with 0, it would change their meaning and
-possibly their value) and hexadecimal by "0x"Â :
-
-- `0b10` (which is equal to `2`)
-- `010` (which is equal to `8`)
-- `0x10` (which is equal to `16`)
-
-**short**
-
-Just like `int`, but on 16-bit only. It makes sense for instance to restrict the
-size when the code is expected to run in production on embedded devices with
-smaller architecture, but it could also allow some compiler optimization and is
-also a way to state you don't expect the values handled to go above $2^{31}-1$
-or under $-2^{31}$. For this reason, all the previous valid values can only be
-`short` except of course the two bounds, which are instead :
-
-- `-32768`
-- `32767`
-
-**long**
-
-A 64-bit for integer, not native at the time hence requiring some astute
-handling from the compiler and less performance when used on the 32-bit machines
-of the time, but handled natively nowadays. Like the previous ones, except for
-the bound which start to be really large and which exact values are left as an
-exercise to the reader.
-
-**float**
-
-Java also has representation for decimal numbers on 32-bit with the `float`
-type, allowing for efficient decimal computations still handled natively by the
-processor. Numbers of this type can be written as the previous integers (granted
-they don't exceed the maximum precision for this type), with a point separating
-an integer part and a fraction part (which can be empty to mean $0$), like this :
-
-- `1.03`
-- `-0.041`
-- `1024.0`
-- `320.`
-
-It also accepts scientific notation with a *significand* (sometimes also called
-*mantissa*) and an *exponent*, the power of ten by which to multiply the
-significand, separated by a lowercase or uppercase 'e'. The previous numbers can
-thus also be written :
-
-- `10.3e-1`
-- `-4.1e-2`
-- `1.024E3`
-- `3.2e2`
-
-Since a float must store both the significand and the exponent on "only" 32-bit,
-they have less space to store digits and can have less precision than `int`
-values. For instance, the value `1.00000001e8` for a float is equal to
-`1e8` for Java (while their `int` equivalents, `100000001` and
-`100000000` are perfectly distinct).
-
-**double**
-
-The `double` type is to `float` what `long` is to `int`Â : semantically the same,
-accepting the same literal values, but with twice as much precision by storing
-the numbers on 32-bit instead. If stored in a `double`, then
-
-- `1.00000001e8` is different from
-- `1e8`
-
-By default, any value in decimal notation is expected by Java to be a `double`,
-which is why the previous constant values can be suffixed by a lowercase or
-uppercase `f` or `d` to mean they are respectively `float` or `double` like so :
-
-- `1.03f` (explicitly float)
-- `1.03d` (explicitly double)
-
-
-**char**
-
-Finally, characters are represented by a their numeric code in Unicode. They are
-stored on 16 bits. A value of this type must be written between single quotes
-likes this :
-
-- `'a'`
-- `'$'`
-- `'6'`
-- `'Z'`
-
-Some special characters can't be entered conveniently in programs and are
-represented by *escape sequences*Â : a '\\' (backslash) followed by a character
-which isn't interpreted litteraly but is translated. This notation isn't
-specific to Java and can be looked up in any ASCII table, but the most useful
-are :
-
-- `'\n'`Â : newline character
-- `'\r'`Â : carriage return (with the previous character, involved in the various
- ways to represent the actual end of line : while UNIX generally considers
- `'\n'` to be enough, Windows wants both `'\r'`, then `'\n'` and MacOS is
- satisfied with `'\r'`)
-- `'\t'`Â : tabulation
-
-Of course, since the single quote marks the end of a character literal, it
-must be escaped to be entered too :
-
-- `'\''`
-
-And that entails that the backslash must be escaped too
-
-- `'\\'`
-
-Characters being from the Unicode charset can also be represented by their
-Unicode code point, with an escaped 'u' followed by the four-digits code point.
-Thus,
-
-- `'\u00e9'` represents the same value as
-- `'é'`
-
-### Compounds
-
-Java also comes with more complex data structures that can be used to model
-real-world data. As we have seen in the introduction, these can't be represented
-natively by the processor and processing them needs more computation power.
-
-For instance there's a type for arbitrary-large numbers, called `BigInteger`.
-Don't believe it's actually infinite, since your machine has only finite memory
-in the end, but it's much larger than the 64 bits allowed to a `long` and
-reaching that limit will mean you'll have exhausted all your computing resources
-so you'll have much more serious problems to worry about than the representation
-overflow.
-
-Possibly the most useful compound type is `String`. It allows to represent text,
-as sequences of characters.
-
-Integers (!)
-Strings
-«struct» -> in fact classes (but let's not talk about the object model just yet)
-
-tip : lower-case -> primitive type, upper-case first -> class
-
-There are of course many more useful built-in types but the most important thing
-to
-
-Please note the attention given to the typographic conventions : while primitive
-types were written all lowercase, classes (we're not quite ready to define them
-but we'll get [there](#objects) soon) in Java start with an uppercase letter.
-Since spaces are not allowed within names, when a name is made of several words,
-the initial of each word is capitalized too, too help read the subwords. This
-convention is called "CamelCase".
-
-(remark on conventions)
-
-## Syntax and semantics
-
-### Types and values
-
-### Variables
-
-### Operators
-
-### Statements
-
-### Applied magics : built-ins
-
-## Control structures
-
-### Functions
-
-Parallel : constants -> variables / list of predefined instructions ->
-dynamic route
-
-### Conditionals
-
-```
-if([type boolean expression])
- [expression]
-else
- [expression]
-```
-
-```
-switch([type X expression]) {
- case [type X litterl]:
- [expression]
- break;
- case [type X litteral]:
- [expression]
- break;
- default:
- [expression]
-}
-```
-
-online ternary
-
-```
-[boolean expression] ? [type X expression] : [type X expression];
-```
-
-### Loops
-
-```
-for([initialization]; [pre-loop condition]; [post-loop expression]) {
- …
-}
-```
-
-```
-for([variable declaration] : [Collection<X> expression])
- [expression]
-```
-
-```
-while(<condition>)
-```
-
-### Exception handling
-
-## Objects
-
-Plato, the Cave metaphor
-
-Plato vs. Aristotle, thought that knowledge of those objects had to be prenatal
-while Aristotle argued for experience and a-posteriori abstraction.
-
-### Classes
-
-### Scopes
-
-Who sees what ?
-
-instantiated object vs. static
-
-public / private / protected
-
-(final)
-
-### Relations between classes
-
-#### Inheritance
-
-"expanding" an existing behaviour
-
-/!\ != subtyping in both ways
-
-#### Virtual classes
-
-#### Interfaces
-
-# Know-how
-
-In the last part of this course, I'd like to confront what we've seen before
-with the technical reality of a compiler.
-
-## The compiler
-
-c.f. supra, a java executable
-
-Let's build a Hello World !
-
-### Formats
-
-**.class**
-
-**.jar**
-
-### Packages
-
-Where to issue the commands ?
-How to name things ?
-How to handle dependencies ?
-
-namespace, "reverse domain name"
-
-parallel class path (separated with '.') vs. folder paths (separate with '/')
-
-## Documentation
-
-Browsing the classes tree, understanding interfaces, knowing what to look for
-
-## Troubleshooting
-
-- CLASSPATH
-
-### Prototyping
-
-`jshell`
-
-### Static errors
-
-### Runtime errors
-
-How to read a stack trace.
diff --git a/IST-4-JAV.md b/IST-4-JAV.md
index 40848c70a1ef8b47fef457689df80009407b25ec..e518768d5c385e848c1e87b26cac5652f853316c 100644
--- a/IST-4-JAV.md
+++ b/IST-4-JAV.md
@@ -2,14 +2,18 @@
title: IST-4-JAV: Java programming
---
+#
+
# Classes
-- 2022-09-21 (wed./æ°´): the [slides](no-backup/Class1.pdf), the [worksheet](no-backup/Worksheet1.pdf) for practice
-- 2022-09-24 (wed./æ°´): the [slides](no-backup/Class2.pdf), the [worksheet](no-backup/Worksheet2.pdf) for practice
-- 2022-09-28 (wed./æ°´): the [slides](no-backup/Class3.pdf), the [worksheet](no-backup/Worksheet3.pdf) for practice
-- 2022-10-19 (wed./æ°´): the [slides](no-backup/Class4.pdf), the [worksheet](no-backup/Worksheet4.pdf) for practice
-- 2022-10-20 (wed./æ°´): the slides, the worksheet for practice
+- 2023-10-02 (mon./月): the [slides](IST-4-JAV/Class1.pdf), the [worksheet](IST-4-JAV/Worksheet1.pdf)
+- 2023-10-04 (wed./æ°´): the [slides](IST-4-JAV/Class2.pdf), the [worksheet](IST-4-JAV/Worksheet2.pdf)
+- 2023-10-06 (fri./金): the [slides](IST-4-JAV/Class3.pdf), the [worksheet](IST-4-JAV/Worksheet3.pdf)
+- 2023-10-11 (wed./æ°´): the [slides](IST-4-JAV/Class4.pdf), the [worksheet](IST-4-JAV/Worksheet4.pdf)
+- 2023-10-13 (fri./金): the [slides](IST-4-JAV/Class5.pdf), no worksheet! (let's
+ just finish everything left over from the previous ones, get started on the
+ assignment and ask questions while it's time)
# Evaluation
-Due 2022-11-09 (wed./æ°´): the [assignment](no-backup/Assignment.pdf)
+Due 2023-10-29 (sun./æ—¥): the [assignment](IST-4-JAV/Assignment.pdf)
diff --git a/Slides/Class1.md b/Slides/Class1.md
index 91cb48c294e018e9a1b82640dbb6a729689705bc..4648eb34517f3ec37f95cab25befc06035141964 100644
--- a/Slides/Class1.md
+++ b/Slides/Class1.md
@@ -2,16 +2,16 @@
title: IST-4-JAV Java Programming
subtitle: Class 1 — (re ?)Discovering Java
author: Alice BRENON `<alice.brenon@liris.cnrs.fr>`
-date: 2022-09-21
+date: 2023-01-02
institute:
\includegraphics[height=.9cm]{figures/LIRIS}\quad
\includegraphics[height=.9cm]{figures/INSA}
header-includes:
- \usepackage{fdsymbol}
- \usepackage{textgreek}
- \usepackage{bclogo}
- \usepackage{Beamer/beamerthemePerso}
- \setcounter{tocdepth}{1}
+ - \setcounter{tocdepth}{1}
+ - \usepackage{fdsymbol}
+ - \usepackage{textgreek}
+ - \usepackage{bclogo}
+ - \usepackage{Beamer/beamerthemePerso}
---
## Foreword: the IST-4-JAV course {-}
@@ -20,30 +20,29 @@ header-includes:
#### 20h: 5×4h-sessions
-- 2022-09-21 (today !)
-- 2022-09-28
-- 2022-10-12
-- 2022-10-19
-- 2022-10-26
-- (every wednesday 8:00 - 12:00 until october the 26\textsuperscript{th}
- included except 2022-10-05)
+- 2023-10-02 8 a.m. (today!)
+- 2023-10-04 2 p.m.
+- 2023-10-06 8 a.m.
+- 2023-10-11 2 p.m.
+- 2023-10-13 8 a.m.
+
+- (one class every other day this week, same last week except monday)
#### Time repartition
- ~2h course
-- (some break in-between)
+- (a break in-between)
- ~2h practice
-### Course material
+### Course home
[https://perso.liris.cnrs.fr/abrenon/IST-4-JAV.html](https://perso.liris.cnrs.fr/abrenon/IST-4-JAV.html)
### How to pass this class ?
-#### Evaluation
+**Evaluation**
-- Game project demonstrating the object-oriented concepts seen in class
-- Remediation exam: some (boring) test on paper (no computer allowed)
+Game project demonstrating the object-oriented concepts seen in class
#### Time-budget
@@ -58,61 +57,52 @@ header-includes:
# About programming
-## Maths vs. Calculation
-
-### Common misconception
-
-{height=200}
-
-
-\begin{center}
-but…
-\end{center}
+## Modeling things
-### Actually…
+### Back to maths 101
:::columns
-::::column
-**Maths**
-
-- theorems
-- formula
-- reductio ad absurdum
-- *no time*
-::::
-::::column
-**Computing**
-
-- "path" to the result
-- notion of *efficiency*
-- simple rules
-- "boring" because…
-- simple / repetitive
+::::{.column width=35%}
+What is a *number* ?
::::
:::
-### Fun with… numbers
+. . .
:::columns
-::::column
+::::{.column width=55%}
Let's consider: **3**
-- $\dot{.\hspace{.095in}.}$ (set) ?
- $\triangle$ (geometric property) ?
+
+. . .
+
+- $\{a, b, c\}$ (set) ?
+
+. . .
+
- $succ(succ(succ(0)))$ (Peano arithmetic) ?
+
+. . .
+
- $\frac{51}{17}$ (result of a computation) ?
. . .
:::
-::::column
+::::{.column width=40%}
**Base b**
-$$\sum_{i=0}^{\infty}{c_i * b^i}$$
-
- `11` (base 2)
+
+. . .
+
- `3` (base 13)
+. . .
+
+$$\sum_{i=0}^{\infty}{c_i * b^i}$$
+
::::
:::
@@ -132,9 +122,9 @@ $$\sum_{i=0}^{\infty}{c_i * b^i}$$
:::
\begin{align*}
-I + II & = III & \text{easy !}\\
+I + II & = III & \text{easy!}\\
I + IV & = V & \text{uh ?}\\
-XCV + V & = C & \text{haha good one romans \^{}\^{}}\
+XCV + V & = C & \text{haha good one romans \^{}\^{}}
\end{align*}
- hard to write addition rules
@@ -159,13 +149,13 @@ $$132 + 41 = ??$$
. . .
\begin{center}
-…in base 5 !
+…in base 5!
\end{center}
::::
:::
-### Back to elementary school !
+### Back to elementary school!
\begin{center}
\begin{tabular}{c | c c c c c}
@@ -232,7 +222,7 @@ $$132 + 41 = ??$$
::::
:::
-### Let's check !
+### Let's check!
\begin{align*}
132 & = 2*5^0 + 3*5^1 + 1*5^2 = 2 + 15 + 25 = 42 \\
@@ -244,8 +234,6 @@ $$132 + 41 = ??$$
$\medbackslash\,\hat{}$ $\theta$ $\hat{}\,\medslash$
\end{center}
-## Modeling things
-
### A *model* of numbers
- a concept: *numbers*
@@ -288,6 +276,81 @@ $\medbackslash\,\hat{}$ $\theta$ $\hat{}\,\medslash$
$\updownarrow$ compilation / interpretation
::::
:::
+## Expressing computations
+
+### Imperative
+
+:::columns
+::::{.column width=45%}
+- "do things in a given order"
+- recipe
+- implicit reference to a state
+::::
+::::{.column width=50%}
+
+. . .
+
+```C
+for(int i = 0; i < 4; i++) {
+ a[i] += 1;
+}
+```
+::::
+:::
+
+### Functional
+
+:::columns
+::::{.column width=45%}
+- "describe the computation itself"
+- based on lambda-calculus
+- everything is a function ($\Rightarrow$ higher-order)
+::::
+::::{.column width=35%}
+
+. . .
+
+```haskell
+fmap (+1) positions
+```
+::::
+:::
+
+### Object
+
+:::columns
+::::{.column width=45%}
+- "as a metaphor of a physical object"
+- associate data and logic
+- explicit reference to an identified state
+::::
+::::{.column width=45%}
+```java
+for(Cell cell : cells) {
+ cell.incr();
+}
+```
+::::
+:::
+
+### Anything else ?
+
+. . .
+
+- logic:
+
+```
+sum(s(a), b) :- sum(a, s(b))
+```
+. . .
+
+- concatenative:
+```
+: fac 1 swap 1+ 1 ?do i * loop ;
+```
+. . .
+
+- (machine learning ?)
### Compiling vs. Interpreting
@@ -303,20 +366,28 @@ $\updownarrow$ compilation / interpretation
- translated on the fly (duality program / data)
- generally slower (+ loading time)
-- portable !
+- portable!
::::
:::
-## Numbers again
+### Typing
-### Calculators
+*Labels* on things in the memory:
-- boring rules
-- long when numbers grow
+- "strong" or "weak"
+- explicit or implicit
+- static or runtime
+- more or less expressive
+ + `void*`
+ + (G)ADT
+ + entire logic system
-\begin{center}
-$\rightarrow$ automation needed !
-\end{center}
+## Actually running them
+
+### A finite memory
+
+- hopefully "big enough"
+- representing *numbers*
. . .
@@ -338,7 +409,7 @@ $\rightarrow$ automation needed !
. . .
-$\bcdanger$ physical limits (overflow)
+- which can represent *things*
### Anything is a number
@@ -351,32 +422,16 @@ obvious **but** overflow
- **Characters**
+ very natural (remember non-positional systems ?)
- + known for very long (before Cæsar) !
+ + known for very long (before Cæsar)!
+ $\rightarrow$ encodings (ASCII, UTF-8…)
#### As a sequence
-- notion of memory
+- notion of address
- special strategies: "stop" symbol vs. length
- "large" numbers
- text
- multimedia
-### Physically
-
-:::columns
-::::column
-{height=120px}
-::::
-::::column
-{height=120px}
-::::
-:::
-
-- many more wires
-- *control* wires vs. *data* wires
-- $\rightarrow$ registers
-- operations are numbers too !
-
### The right word
An *atomic* number $\doteq$ a *word*
@@ -422,12 +477,12 @@ $\Rightarrow$ we can have *programs* pretending to be *machines* (see Turing mac
**Compiled or interpreted ?**
- compiles to a binary: *bytecode*…
-- but for a *virtual machine* ! "JVM"
+- but for a *virtual machine*! "JVM"
- "Write Once Run Anywhere"
**Features**
-- Object-Oriented
+- Object-Oriented (+ Imperative)
- strictly typed: forget that "anything is a number"
- rich collection of built-ins for data structures, I/O…
- automatic memory handling (garbage collector)
@@ -437,7 +492,7 @@ $\Rightarrow$ we can have *programs* pretending to be *machines* (see Turing mac
**Context**
- released in 1995 (32-bits architectures)
-- after the Eternal September !
+- after the Eternal September!
**Internet oriented**
@@ -488,15 +543,17 @@ $\rightarrow$ *flags*
must be annotated with its type (Java does it too and compares)
-### Pro-tip
+### A REPL!
-In `jshell` type
+In `jshell`[^1] (Read - Eval - Print Loop) type
- */vars* : to print the known variables with their type
- */set feedback verbose* : to include the type of expressions in the evaluation
output
-This is **not Java** ! only special commands for the interpreter
+[^1]: [https://tryjshell.org/](https://tryjshell.org/)
+
+This is **not Java**! only special commands for the interpreter
## Data structures
@@ -506,7 +563,7 @@ This is **not Java** ! only special commands for the interpreter
::::{.column width=100%}
#### Truth values
-- `boolean` useful for tests
+- `boolean` useful for conditionals
::::
:::
@@ -605,7 +662,7 @@ This is **not Java** ! only special commands for the interpreter
#### Problems with constants
- "Don't Repeat Yourself"
-- they don't carry any *intention* ("beware of names" said I !!)
+- they don't carry any *intention* ("beware of names" said I!!)
- "constants" change sometimes (e.g. exchange rate)
### Variables
@@ -659,8 +716,10 @@ This is **not Java** ! only special commands for the interpreter
### Functions
- abstracts a computation by isolating its inputs
-- name it ("beware of names" !)
-- has several input types and one output type for its result
+- name it ("beware of names"!)
+- has several input types (for its arguments) and one output type (for its
+ result)
+- its arguments are written within parentheses (both in declaration and call)
#### Built-in functions examples
@@ -721,7 +780,7 @@ This is **not Java** ! only special commands for the interpreter
**Consequences**
- only objects can be `null`
-- but `null` isn't an object
+- but **`null` isn't an object**
- `==` / `!=` on objects compare addresses
## Expressions and Statements
@@ -813,19 +872,10 @@ is an **expression** of type `t` with value "projected" from `<VALUE>`
(short) 4 // still 4, but coded on 16 bits
(byte) 'c' // == 99
(float) (2.5 / 2) // still 1.25, but as a float
-```
-
-A full example of truncation
-
-```java
-int gregYear = 2022; // set an initial value
-byte byteGregYear = (byte) gregYear; /* works, but
-byteGregYear ==> -26
-the 32-bits int was truncated to 8-bits byte !
-(and 2022 % 0x100 == -26)*/
-(int) byteGregYear;
-/* $3 ==> -26
-the original information was lost */
+(int) 7.2 // truncates to 7
+(int) 7.9 // 7, it truncates and doesn't round
+(float) ((int) 7.2) // still 7.0, information was
+ // lost
```
### Function application
@@ -847,7 +897,7 @@ the original information was lost */
```java
!false
total / count
-"Hello, " + "world !"
+"Hello, " + "world!"
Math.pow(Math.E, -1)
System.out.println(someMessage);
```
@@ -1045,20 +1095,6 @@ java [OPTIONS] PATH_TO_BYTECODE
## For today
-### A REPL !
-
-- (Read - Eval - Print Loop)
-- useful to test stuff while programming
-- also to find bugs
-
-```sh
-jshell
-```
-
-enters a prompt which evaluates Java code
-
-([https://onecompiler.com/jshell/](https://onecompiler.com/jshell/))
-
### Read the documentation
#### Main page of the official Java documentation
@@ -1076,6 +1112,10 @@ enters a prompt which evaluates Java code
-## Time for practice : ) {-}
+### JShell documentation
+
+[https://cr.openjdk.org/~rfield/tutorial/JShellTutorial.html](https://cr.openjdk.org/~rfield/tutorial/JShellTutorial.html)
+
+### Time for practice : ) {-}
[https://perso.liris.cnrs.fr/abrenon/IST-4-JAV.html](https://perso.liris.cnrs.fr/abrenon/IST-4-JAV.html)
diff --git a/Slides/Class2.md b/Slides/Class2.md
index 4073b0893fe501ad72408fc5f7dc25ee84f357a7..05ead3906ba1d08f8658693877edcbc10717272b 100644
--- a/Slides/Class2.md
+++ b/Slides/Class2.md
@@ -7,16 +7,16 @@ institute:
\includegraphics[height=.9cm]{figures/LIRIS}\quad
\includegraphics[height=.9cm]{figures/INSA}
header-includes:
- \usepackage{fdsymbol}
- \usepackage{textgreek}
- \usepackage{bclogo}
- \usepackage{Beamer/beamerthemePerso}
- \setcounter{tocdepth}{1}
+ - \usepackage{fdsymbol}
+ - \usepackage{textgreek}
+ - \usepackage{bclogo}
+ - \usepackage{Beamer/beamerthemePerso}
+ - \setcounter{tocdepth}{1}
---
# Making functions and procedures
-## Why ?
+## Why?
### Previously on IST-4-JAV…
@@ -31,18 +31,18 @@ while(initValue > 1) {
}
}
```
-- `initValue` is modified !
+- `initValue` is modified!
- $\rightarrow$ need to reset it
- naming issue: at the end it's actually the "final" value
- not *reusable* nor *composable*
-### Function as an interface
+### Functions as an interface
#### Documentation
- identifies what is needed
-- partly documents through types
-- beware of the naming though !
+- partly document things through types
+- beware of the naming though!
#### Local variables
@@ -51,9 +51,9 @@ while(initValue > 1) {
- can even reuse name (dangerous though)
- notion of *scope*
-## How ?
+## How?
-### Example: is a `char` contained in a `String` ?
+### Example: is a `char` contained in a `String`?
We know how to
@@ -107,14 +107,14 @@ return; // ok in a procedure (void function)
**Incorrect use**
```
-int n = return 2; // bad ! won't compile
-someFunction(return 2); // bad ! won't compile
+int n = return 2; // bad! won't compile
+someFunction(return 2); // bad! won't compile
// either
```
### The body
-- "regular" (= *imperative*) code like in `jshell`
+- "regular" (= *imperative+object*) code like in `jshell`
- "virtual" environment, "suspended" computation, "assumption"
- can declare variables, use statements, call other functions…
- every "exit" must be checked: `return;` by default, but that is `void`
@@ -162,7 +162,7 @@ boolean contains(String haystack, char needle) {
:::columns
::::column
-#### Maths, again !
+#### Maths, again!
$$
f\colon \begin{tabular}{r c l}
@@ -210,7 +210,7 @@ Sometimes programs need to
::::
:::
-# More data !
+# More data!
## "Object-Oriented"
@@ -219,12 +219,12 @@ Sometimes programs need to
:::columns
::::column
-{height=100px}
+{height=100px}
::::
::::column
-{height=100px}
+{height=100px}
::::
:::
@@ -234,7 +234,6 @@ Plato: the "Theory of Forms/Ideas"
- "true" reality of this world
- *eternal*, perfect
- they exist *prior to* particular concrete objects
-- Aristotle refuted it
### Classes
@@ -254,7 +253,7 @@ Plato: the "Theory of Forms/Ideas"
- defines a *recipe* for values: *what* and *how*
- defines the use of values
- similar to the *type* of "number" values (`int`, `char`…)
-- you already know: `String` (mind the case !)
+- you already know: `String` (mind the case!)
### Fields
@@ -271,7 +270,7 @@ String building;
### A "constructor"
- define the *how*, the "mold" part
-- it's just a function ! (can take parameters)
+- it's just a function! (can take parameters)
- both the return type *and* the name of the function
- usually initializes the fields
- always a default constructor: no arguments, does nothing
@@ -338,7 +337,7 @@ ClassRoom javaLab = new ClassRoom(17, "Hopper");
- an empty "box" is created
- the code for the constructor is called
-### (What's `this` ? What's `this` ? I can't believe my eyes…)
+### (What's `this`? What's `this`? I can't believe my eyes…)
```Java
Room(int room, String building) {
@@ -377,7 +376,7 @@ is either
- related to the "Form" itself, not to any of its instances
- *shared* space between instances
-- $\implies$ `static` code can refer to `this` !
+- $\implies$ `static` code can refer to `this`!
**Warning**
@@ -387,7 +386,7 @@ fields and methods can be `static` $\neq$ constructors can (obviously) not
`static` values can be initialized
-- during declaration (preferred $\rightarrow$ no constructors !)
+- during declaration (preferred $\rightarrow$ no constructors!)
- within a method (`static` or not)
```Java
@@ -439,7 +438,7 @@ useful for their `static` methods
assuming
-- `a` is a variable
+- `a` is a variable of a class type
- `ClassName` is the name of an existing class
```Java
@@ -456,7 +455,7 @@ String s = "";
Integer n = 4;
s instanceof String // == true
n instanceof Integer // == true
-s instanceof Integer // will break at compile time !
+s instanceof Integer // will break at compile time!
```
## Containers
@@ -490,7 +489,8 @@ once an array `a` of length `n` exists in memory it's like:
- each at index `i` can be:
+ read: `a[i]`
+ written: `a[i] = someNewValue;`
-- its length is stored an accessible: `a.length` (= `n`)
+- its length is stored and readable: `a.length` (= `n`)
+- (but not writable!)
**Warning**
@@ -523,13 +523,13 @@ no "cell as a variable" but
- `.get(int index)` returns the value at `index`
- `.set(int index, E element)` replaces the value at `index`
- `.add(E element)` appends (at the end)
-- `.size()` ($\neq$ `.length` !) the number of elements
+- `.size()` ($\neq$ `.length`!) the number of elements
### "Boxes"
- not "one" type, an (open) "family"
- notion of type "variable" (`E`)
-- any type $\rightarrow$ can be nested !
+- any type $\rightarrow$ can be nested!
can be a "number" type or a class for arrays
@@ -539,7 +539,7 @@ String[] cheeseNames = {"camembert", "maroilles"};
int[][] matrix = new int[5][5];
```
-must be a class for object containers
+**must be a class** for object containers
```Java
ArrayList<Integer> grades;
@@ -560,7 +560,7 @@ new LinkedList<String>()
- arrays: `.length` is `final` (ro)
- object containers: `.add`
-# More control structures !
+# More control structures!
## Switch / case
@@ -608,7 +608,7 @@ String inFrench(int number) {
}
```
-### A new construct !
+### A new construct!
- a block:
@@ -688,7 +688,7 @@ $\rightarrow$ execution jumps and *continues* below from there
- $\rightarrow$ hard to anticipate
- $\rightarrow$ will fail
-**What to do ?**
+**What to do?**
- the program may recover
- exception error messages are "ugly": users should understand the *cause* if
@@ -716,7 +716,7 @@ is a **statement** which
## More on for
-### Remember for ?
+### Remember for?
```Java
for(<INITIALIZE>; <TEST>; <ITERATE>) {
@@ -735,7 +735,7 @@ Actually…
```Java
int nextCollatz(int i) {
- return i % 2 == 0 ? i / 2 : 3*i+1;
+ return i % 2 == 0? i / 2 : 3*i+1;
}
```
. . .
@@ -805,7 +805,7 @@ class Main {
#### Requirements
-- entry point of the program ("where do we start ?")
+- entry point of the program ("where do we start?")
- no context yet, so can't instantiate `Main` class
- $\implies$ `static`, (`public`)
diff --git a/Slides/Class3.md b/Slides/Class3.md
index de2047cb8bfc40817e4c058a3b0902fd051801e0..ab85a1d210320cd57d29cff447166d1da33760a6 100644
--- a/Slides/Class3.md
+++ b/Slides/Class3.md
@@ -8,11 +8,11 @@ institute:
\includegraphics[height=.9cm]{figures/INSA}
aspectratio: 169
header-includes:
- \usepackage{fdsymbol}
- \usepackage{textgreek}
- \usepackage{bclogo}
- \usepackage{Beamer/beamerthemePerso}
- \setcounter{tocdepth}{1}
+ - \usepackage{fdsymbol}
+ - \usepackage{textgreek}
+ - \usepackage{bclogo}
+ - \usepackage{Beamer/beamerthemePerso}
+ - \setcounter{tocdepth}{1}
---
# Structuring objects
@@ -254,7 +254,7 @@ class Cat {
::::
::::{.column width=45%}
```Java
-class DomesticCat {
+class DomesticCat extends Cat {
…
@Override
void feed() {
@@ -275,7 +275,7 @@ class DomesticCat {
- `super` again !
```Java
-class DomesticCat {
+class DomesticCat extends Cat {
…
void feed() {
if(isHumanAround()) {
@@ -307,7 +307,7 @@ default `.toString`: *Class name* + `@` + *memory location*
### A nicer display
```Java
-class DomesticCat {
+class DomesticCat extends Cat {
String toString() {
return this.name + ", a cat";
}
@@ -317,7 +317,7 @@ class DomesticCat {
\vspace{-0.3cm}
```Java
-class PureBreedCat {
+class PureBreedCat extends DomesticCat {
String toString() {
return this.name + ", a " + this.breed + " cat";
}
@@ -355,7 +355,7 @@ Java finds functions by their name **and** signature
(assuming we never wrote the previous implementation with `super`)
```Java
-class DomesticCat {
+class DomesticCat extends Cat {
void feed(Human h) {
System.out.println("mews until human feeds it");
}
@@ -387,7 +387,7 @@ pangur.name; // "Marcel"
### The `private` keyword
```Java
-class DomesticCat {
+class DomesticCat extends Cat {
private String name;
// but still can interact with it !
diff --git a/Slides/Class4.md b/Slides/Class4.md
index d11d19066ff6f06e9793b5cc36c5fe4830d15448..dc4de101befd2666a1aa1219f25c5275b23d56fe 100644
--- a/Slides/Class4.md
+++ b/Slides/Class4.md
@@ -8,11 +8,11 @@ institute:
\includegraphics[height=.9cm]{figures/INSA}
aspectratio: 169
header-includes:
- \usepackage{fdsymbol}
- \usepackage{textgreek}
- \usepackage{bclogo}
- \usepackage{Beamer/beamerthemePerso}
- \setcounter{tocdepth}{1}
+ - \usepackage{fdsymbol}
+ - \usepackage{textgreek}
+ - \usepackage{bclogo}
+ - \usepackage{Beamer/beamerthemePerso}
+ - \setcounter{tocdepth}{1}
---
@@ -37,7 +37,7 @@ One interface, several implementations.
. . .
-$\rightarrow$ an interface !
+$\rightarrow$ an interface!
::::
:::
@@ -91,7 +91,7 @@ $\Rightarrow O(1)$
\vspace{0.5cm}
-does `i == 0 ` ?
+does `i == 0 `?
- if yes, get the head:
- otherwise, get the `i-1`\textsuperscript{th} element of the queue
@@ -136,13 +136,32 @@ $\Rightarrow O(1)$
### Performance comparison
-**So which one is best ?**
+**So which one is best?**
- if frequent random access is needed: `ArrayList`
- if frequent modification is needed: `LinkedList`
$\Rightarrow$ No "one-size-fits-all", implementation should match the use
+### In any case
+
+Previously on IST-4-JAV (class 2)…
+
+notion of **type variable**
+
+. . .
+
+```Java
+List<String> al = new ArrayList<String>();
+```
+
+. . .
+
+```Java
+List<String> ll = new LinkedList<String>();
+
+```
+
## Associating values to keys
### A common need
@@ -166,7 +185,8 @@ interface Map<K, V> {
```Java
class Pair<K, V> {
- …
+ public K getKey() { … }
+ public V getValue() { … }
}
```
@@ -187,7 +207,7 @@ $\downarrow$
\end{center}
```Java
-class PhoneBook<K, V> {
+class PhoneBook<K, V> implements Map<K,V> {
private ArrayList<Pair<K, V>> records;
PhoneBook (int initialSize) {
this.records = new ArrayList<>(initialSize);
@@ -215,7 +235,7 @@ V get(Object k) {
### HashMaps
-A bit of both !
+A bit of `ArrayList` and `LinkedList`!
{width=260px}
@@ -274,32 +294,32 @@ A bit of both !
- **imperative**: "recipe", sequence of instructions
- **object**: "sections" in the program not executed linearly
-$\rightarrow$ what about reactions to events ?
+$\rightarrow$ what about reactions to events?
-- could the program be in "several locations" at once ?
-- how could each step anticipate everything that could happen ? (and always the
+- could the program be in "several locations" at once?
+- how could each step anticipate everything that could happen? (and always the
same anyway)
-- check some central state once in a while ?
+- check some central state once in a while?
### Use cases
- long (> 100 ms) calls: network
-- user interaction (games, anyone ?)
+- user interaction (games, anyone?)
- graphical user interfaces (don't want everything to freeze)
-How to represent reactions ?
+How to represent reactions?
. . .
-Reactions are functions so… could we pass functions after all ?
+Reactions are functions so… could we pass functions after all?
## Functions as values
### So what if we could…
-- store a function into a variable ?
-- associate it to a key ? (menus…)
-- pass it to another function ?
+- store a function into a variable?
+- associate it to a key? (menus…)
+- pass it to another function?
```Java
boolean isEven(int n) {
@@ -308,23 +328,23 @@ boolean isEven(int n) {
someList.filter(isEven); // Error: cannot find symbol
```
-### Interfaces !
+### Interfaces!
-- classes can have (several !) methods
+- classes can have (several!) methods
- passing an object is a way to pass its methods
-- only need a convention to find the method
+- only need a convention to find the (unique) method
-$\rightarrow$ this is called an interface !
+$\rightarrow$ this is called an interface!
```Java
-interface MyFunctionType {
- int run(List<Integer> primes);
+interface IntPredicate {
+ public boolean run(int input);
}
```
### Representing a function
-- special case: interface with only one method to implement
+- special case: interface with *only one* method to implement
- the class is a simple "wrapper" around it
- conventional name to find it
- (can have other methods but only 1 abstract)
@@ -332,48 +352,98 @@ interface MyFunctionType {
$\rightarrow$ it's called a functional interface (pragma `@FunctionalInterface`)
!
-**Example**
-
```Java
@FunctionalInterface
-public interface IntPredicate {
- public boolean test(int t);
+interface IntPredicate {
+ public boolean run(int input);
}
```
-### Ad-hoc inheritance
-
-- `abstract` as "negative" methods
-- $\rightarrow$ "settle the bill"
-- actually `interface`s and `abstract` classes can be instantiated !
+### `isEven` as an `IntPredicate`
```Java
-@FunctionalInterface
-interface IntMapping {
- public int apply(int n);
+class IsEven implements IntPredicate {
+ public boolean run(int input) {
+ return input % 2 == 0;
+ }
}
+
+IntPredicate isEven = new IsEven();
+isEven.run(2); // true
+isEven.run(5); // false
```
+### Ad-hoc inheritance
+
+- `abstract` as a "debt" in methods
+- $\rightarrow$ "settle the bill"
+- you can build *ad-hoc* full-fledged classes from `interface`s and `abstract`
+ ones!
+
. . .
+
```Java
-IntMapping plus2 = new IntMapping() {
- public int apply(int n) {
- return n + 2;
+IntPredicate isEven = new IntPredicate() {
+ public boolean run(int input) {
+ return input % 2 == 0;
}
}
+isEven.run(6); // true
+```
+
+### Leaving without paying
+
+```Java
+IntPredicate isEven = new IntPredicate();
```
+. . .
+
+```
+| Error:
+| IntPredicate is abstract; cannot be instantiated
+| IntPredicate isEven = new IntPredicate();
+| ^----------------^
+```
+
+### Still longish
+
+- dropped the empty `class` shell
+- instantiate directly as we implement
+
+*but*
+
+- still several imbricated `{…}`
+- have to mind the keywords
+
+we just want to map a `<VARIABLE>` *to* an `<EXPRESSION>` (or `<STATEMENT>`)
+
+. . .
+
+**inline function**, aka a "\textlambda" from \textlambda-calculus, (Alonzo
+Church, 1930s)
+
+:::columns
+::::{.column width=20%}
+```
+a -> b
+```
+::::
+:::
+
+
+
### Syntax
assuming
- `(a, b, …)` is a tuple of $n$ variables (parentheses optional when 1 only)
- `<VALUE>` is an expression
-- `<BLOCK>` is a block ending with a `return` statement
+- `<STATEMENT>` is a statement (often of the form `{ …; …; …; }`)
```Java
(a, b, …) -> <EXPRESSION>
-(a, b, …) -> { <BLOCK> }
+(a, b, …) -> <STATEMENT>
```
are values for a given functional interface
@@ -387,18 +457,40 @@ x -> {System.out.println(x); return -x;}
### A little bit shorter
-The previous `plus2` becomes
+The previous example becomes
```Java
-IntMapping plus2 = n -> n + 2
+IntPredicate isEven = n -> n % 2 == 0
```
-It's called an inline function, sometimes also a "\textlambda" from the
-\textlambda-calculus, (Alonzo Church, 1930s).
+- no mention of `run` any longer
+
+. . .
+
+- but still have to mind it!
+
+:::columns
+::::{.column width=45%}
+```Java
+isEven(2);
+```
+```
+// Error:
+| cannot find symbol
+| symbol: method isEven(int)
+```
+::::
+::::{.column width=45%}
+. . .
+```Java
+isEven.run(2); // true
+```
+::::
+:::
### Method reference
-- what about existing functions ?
+- what about existing functions?
- can be wrapped into a \textlambda, but boring:
```Java
n -> someObject.someMethod(n)
@@ -409,17 +501,59 @@ n -> someObject.someMethod(n)
### Example
```Java
-class PartialSum {
- private int firstNumber;
- PartialSum (int initialValue) {
- this.firstNumber = initialValue;
- }
- public int plus(int secondNumber) {
- return this.firstNumber + secondNumber;
- }
+class Arithmetic {
+ …
+ public static boolean isEven(int input) {
+ return input % 2 == 0;
+ }
+ public static boolean isOdd(int input) { … }
+ public static boolean isPrime(int input) { … }
+ …
+}
+IntPredicate[] predicates = {Arithmetic::isEven,
+ Arithmetic::isPrime};
+predicates[0].run(2); // true
+Arithmetic.isEven(2); // true
+```
+
+### Generalizing a bit
+
+```Java
+@FunctionalInterface
+interface Function<I, O> {
+ public O run(I input);
+}
+
+class Multiple {
+ int i;
+ public Multiple(int i) {
+ this.i = i;
+ }
+ public boolean divisible(int j) {
+ return j % this.i == 0;
+ }
}
-PartialSum two = new PartialSum(2);
-IntMapping add2 = two::plus;
+```
+
+### Full example
+
+Remember?
+
+```Java
+someList.filter(isEven); // Error: cannot find symbol
+```
+
+. . .
+
+```Java
+List<Integer> smallerThan10 = new LinkedList<Integer>();
+for(int i = 0; i < 10; i++) {
+ smallerThan10.add(i);
+}
+
+Multiple by3 = new Multiple(3);
+smallerThan10.removeIf(by3::divisible)
+smallerThan10; // smallerThan10 ==> [1, 2, 4, 5, 7, 8]
```
# Graphical User Interfaces
@@ -561,7 +695,7 @@ a function to draw our window
- A window is a `JFrame`, set its title
- make the program end when the window closes
- find a size that works for components
-- show the window (yes !)
+- show the window (yes!)
### Translation
@@ -572,8 +706,8 @@ public static void main(String[] args) {
```
- still a program like any other, needs the usual `main`
-- schedule a rendering (see the lambda ?)
-- where did the control flow go ?
+- schedule a rendering (see the lambda?)
+- where did the control flow go?
### With a panel
@@ -595,7 +729,7 @@ import java.awt.GridLayout;
…
private static void createAndShowGUI() {
…
- JLabel label = new JLabel("Hey there !");
+ JLabel label = new JLabel("Hey there!");
JTextField input = new JTextField();
JButton submit = new JButton("click me");
jpanel.add(label);
diff --git a/Slides/Class5.md b/Slides/Class5.md
index 69661bdbc0726276e3fb2f516892d7a05f8a9c05..4a761f8f69527ac9fe7a98a3e6e815f92604005e 100644
--- a/Slides/Class5.md
+++ b/Slides/Class5.md
@@ -8,11 +8,11 @@ institute:
\includegraphics[height=.9cm]{figures/INSA}
aspectratio: 169
header-includes:
- \usepackage{fdsymbol}
- \usepackage{textgreek}
- \usepackage{bclogo}
- \usepackage{Beamer/beamerthemePerso}
- \setcounter{tocdepth}{1}
+ - \usepackage{fdsymbol}
+ - \usepackage{textgreek}
+ - \usepackage{bclogo}
+ - \usepackage{Beamer/beamerthemePerso}
+ - \setcounter{tocdepth}{1}
---
# Types
@@ -183,7 +183,7 @@ is `List<Integer>` a "subtype" of `List<Object>` ?
. . .
-= "if I get a `List<Integer>`, do I have a `List<Object>` ?
+= "if I get a `List<Integer>`, do I have a `List<Object>` ?"
```Java
List<Integer> ints = new ArrayList<>();
@@ -327,7 +327,7 @@ static <T,U extends Comparable<? super U>> Comparator<T>
- `U` must be comparable with any type inheriting it
- `Comparator<T>`: this returns a comparator (on objects of type `T`)
- `keyExtractor` a function
- + `<? super T>` from something that inherits `T`
+ + `<? super T>` from something `T` inherits from
+ `<? extends U>` to something that inherits `U`
"If you can map `T` to a type `U` which you know how to compare, you can compare
@@ -412,7 +412,7 @@ abstract class InputStream {
```
…
```Java
- int read()
+ int read() throws IOException
```
…
```Java
@@ -703,7 +703,7 @@ class VolumeBar {
::::
::::{.column width=55%}
-{height=230px}
+{height=230px}
::::
:::
@@ -740,23 +740,48 @@ javadoc [PACKAGE|SOURCE-FILE]
### Example
```Java
-class StringUtil {
- /**
- * Replicate a String several times
- * @param input the initial String
- * @param n the number of repetitions
- * @return the initial String concatenated the n times
- */
- public static String replicate(String input, int n) {
- if(times == 0) {
- return "";
- } else {
- return input + replicate(input, times - 1);
- }
- }
+/** A class exposing handy functions to generate Strings */
+public class StringUtil {
+ /** Replicate a String several times
+ * @param input the initial String
+ * @param n the number of repetitions
+ * @return the initial String concatenated the n times */
+ public static String replicate(String input, int n) {
+ if(times == 0) {
+ return "";
+ } else {
+ return input + replicate(input, times - 1);
+ }
+ }
}
```
+### Generated files
+
+:::columns
+::::{.column width=50%}
+
+::::
+:::
+
+### The main page (`index.html`)
+
+:::columns
+::::{.column}
+
+::::
+:::
+
+no package, and `javadoc` resents it!
+
+### The class itself
+
+:::columns
+::::{.column}
+
+::::
+:::
+
## Classpath
### In java
diff --git a/Worksheet/Worksheet1.md b/Worksheet/Worksheet1.md
index 140e7636830e3dbc9bcec03dd42c81b709f07f4b..0f001eae3949b7864b58e6930b4513c144e207f7 100644
--- a/Worksheet/Worksheet1.md
+++ b/Worksheet/Worksheet1.md
@@ -2,88 +2,171 @@
title: Worksheet 1
---
-# Warming-up (1h ?)
+# Together (Language basics)
-## Assignments
+## Native "numbers"
-Create an `int` variable to represent the number of sides for a polygon and
-initialize it to `3` (triangle).
+Java (as well as most languages) is a bit like a calculator. Just type the
+inputs on the slides
-- Create a `String` variable to represent the name of the person next to you
- without initializing it right away.
-- Now set it to its appropriate value.
-- Then, change it to your own name. Finally, try to set it to the value `null`.
+Java (as well as most languages) is a bit like a calculator. Typing very simple
+calculations is already a Java expression. Try:
-Can you create a variable of type `void` ? Why ?
+- `-3 * 2`
+- `2147483647 + 1`
-## Casts
+What happens? Why?
-- Create a `short` variable representing the current year number in the
- Gregorian Calendar.
-- Now cast it to `byte`: what happens ?
-- Store the resulting value into a `byte` variable. Do you get your value back
- when casting this second variable back to `short` ? What's going on ?
+Now try the decimal numbers examples in `jshell`. What is different?
-- Create a `byte` variable representing the current month in the same calendar.
-What happens if you cast it to `short` ? And if you cast a second time back to
-`byte` on to of the value obtained after the first `short` cast (sprinkle
-parenthesis liberally) ?
+## Functions
+
+Let's play with `Integer.parseInt`. What does this return? (pay attention to the
+type)
+
+- `Integer.parseInt("1")`
+- `Integer.parseInt("-2")`
+- `Integer.parseInt("one")`
+
+What about edge cases?
+
+- `Integer.parseInt("2147483647")`: still working?
+- How about `Integer.parseInt("2147483648")`?
+
+Now type `Integer.parseInt`. Press the tabulation key once. What happened? Press
+it a second time. Anything new?
+
+Finally, let's give `Math.max` a try. Try to predict the output (type included)
+of:
+
+- `Math.max(2, 7)`
+- `Math.max(-2., 2)`
+- `Math.max(7, 3, 6)`
+
+## Procedures
+
+Try:
+
+- `Thread.sleep(100)`
+- `Thread.sleep(500)`
+- `Thread.sleep(2000)`
+
+What do you think does the argument represents? What about
+
+- `System.exit(0)`
+- `System.exit(1)`
+
+## Let's try operators
+
+### Modular arithmetic
+
+Evaluate:
+
+- `8 / 2`
+- `7 / 2` (is the result what you expected?)
+- `7. / 2`
+- `7 % 2`
+
+How could we write a test to detect even (and, conversely, odd) numbers with
+this?
+
+### Binary logic
+
+What is
+
+- `3 && 5` ?
+- `3 & 5` ? Why?
+- `3 ^ 5`
+
+Pick a two-digits hexadecimal numbers. `&` it with `255`. What is the result?
+Why?
+
+### Comparisons
+
+- Evaluate `3 == 4`. What does `jshell` return ? Is that an expression or a
+statement?
+- What about `4 == 4`?
## Statements and Expressions
+### Casts
+
+- Create a `short` variable representing the current year in your game (fancy a
+ Renaissance FPS, anyone? please just don't use anything before the Roman
+ empire collapse — 476).
+- Now cast it to `byte`: what happens?
+- Store the resulting value into a `byte` variable. Do you get your value back
+ when casting this second variable back to `short`? What's going on?
+- Create a `byte` variable representing the current month in the same calendar.
+ What happens if you cast it to `short`? And if you cast a second time back to
+ `byte` on to of the value obtained after the first `short` cast (sprinkle
+ parenthesis liberally)?
+
### Printing vs. evaluating
-Print the name of the person next to you (use `System.out.println`). Is the
-output of `jshell` any different from when you simply have it evaluate the
-variable containing it ? Why ?
+Print the name of your character (use `System.out.println`). Is the output of
+`jshell` any different from when you simply have it evaluate the variable
+containing it? How?
-Can you copy the content of this variable to a new variable ? Can you do the
+Can you copy the content of this variable to a new variable? Can you do the
same with the printing statement (`String copy =
-System.out.println(neighborName)`) ?
+System.out.println(characterName)`)? Why?
+
+### Assignments
+
+- Create an `int` variable to represent the number of lives in your future game
+ and initialize it to `3`.
+- Create a `String` variable to represent the name of your character without
+ initializing it right away.
+- Now set it to its appropriate value (sorry, "Zelda" and "Pikachu" are taken).
+- Finally, set it to the value `null`.
+
+Can you create a variable of type `void`? Why?
+
+### Conditional statements
+
+- Choose an integer between 1 and 100 and store it to a variable called `secret`.
+- Ask your neighbour to guess it and store what their answer as second variable
+ called `playerInput`.
+- Write an `if` conditional statement to print whether the initial secret number
+ was less or more than their guess, or if they guessed right.
+
+---
+
+# Individual practice
+
+## More about comparisons
### Computing new values
-Now dynamically create a `String` value containing an at sign (`@`) immediately
-before the name of the person next to you. Store the value you get to a new
-variable called `nick`.
+Let us create a `String` value containing an at sign (`@`) immediately before
+the name of your character. Store the value you get to a new variable called
+`nick`.
- Look up the documentation for the `String` class and find how to compute a new
string skipping the first characters from a given input string.
-- Use it to print your neighbor's name using the `nick` variable instead of the
+- Use it to print your character's name using the `nick` variable instead of the
original variable containing it.
-- Store the corresponding value to a new variable called `computedNeighborName`.
+- Store the corresponding value to a new variable called
+ `computedCharacterName`.
-### Comparing
+### Some more comparisons
-- Evaluate `3 == 4`. What does `jshell` return ? Is that an expression or a
-statement ?
-- What about `4 == 4` ?
-- What about `neighborName` == `neighborName` ?
-- And what about `neighborName` == `computedNeighborName` ?
-- How can you explain what you observe ?
+- What about `characterName` == `characterName`?
+- And what about `characterName` == `computedCharacterName`?
+- How can you explain what you observe?
-# Loops (1h ?)
+## Loops
-## The ASCII set
+### The ASCII set
Use casts to perform conversions between a character and its code (both to and
from).
Now, iterate over the $[0, 255]$ range to print each character next to its code.
-You got yourself an ASCII table !
-
-## Rot13
-
-Cæsar's Rot13 was a clever (well at the time at least) scheme to cipher
-messages. From a given input message, he would replace all letters with the
-letter 13 ranks after in the alphabet (wrapping at 'z' of course).
+You got yourself an ASCII table!
-Find a way to compute the replacement letter for a given initial letter.
-
-Now declare a String variable holding a message and write a loop to print its
-Rot13 encoding (you want to look `.charAt()` up).
-
-## Collatz conjecture
+### Collatz conjecture
Pick any integer number you want and save it as `int currentValue`. Now apply
the current rule:
@@ -93,3 +176,14 @@ the current rule:
Repeat a couple times. What do you observe ? Can you make a conjecture ? When
will it stop ? Write a `while` loop verifying it.
+
+### Rot13
+
+Cæsar's Rot13 was a clever (well at the time at least) scheme to cipher
+messages. From a given input message, he would replace all letters with the
+letter 13 ranks after in the alphabet (wrapping at 'z' of course).
+
+Find a way to compute the replacement letter for a given initial letter.
+
+Now declare a String variable holding a message and write a loop to print its
+Rot13 encoding (you want to look `.charAt()` up).
diff --git a/Worksheet/Worksheet2.md b/Worksheet/Worksheet2.md
index 17a6e3f755a34386eb69fd6d45be105d12f9cc3d..6b9f2da9aafaf8881374e80cb3e3a7385d3e86ce 100644
--- a/Worksheet/Worksheet2.md
+++ b/Worksheet/Worksheet2.md
@@ -2,28 +2,120 @@
title: Worksheet 2
---
-# Fun with funs
-
-## Collatz returns !
-
-Remember what we did from slide 9 to 14, turning the implementation idea from
-slide 13 ("Implementing the body") into a proper Java function ?
-
-Look at the code from slide 5 giving a solution for the last exercise of
-practice 1 printing a Collatz sequence from a given number.
-
-- identify the *interface* of this procedure: what argument(s) does it need ?
- what are their types ?
-- it's a procedure: what will its return type be ?
-- can you describe what this function is doing ? Find a good name for it.
-- now turn this one-time snippet into a proper function
-
-Now you can easily visualize Collatz sequences from any input number you want.
-Use it to manually check that the Collatz conjecture holds for all integers
-between `1` and `10`.
+# Our first mini-game
+
+We will now create our first command-line program, a very simple game in which
+the player must guess a number.
+
+## A functional interface
+
+Remember the conditional statement we wrote in the first worksheet to print
+whether a `guess` was greater or lower than a `secret` ? It was enough to try it
+just for once, but it wouldn't be very convenient if we had to evaluate it
+several times, having to alter the `guess` variable in between. Let's wrap it
+into a proper procedure (just write it in a text file, evaluate it and try it in
+jshell, it'll become a class very soon I promise).
+
+- what inputs would this procedure take? what are their types (we can just keep
+ the same names we already had for the variables)?
+- what should be its return type (hint, it's a *procedure*, not a *function*)
+- pick a proper name for this new function and implement it (its body should
+ just be the same code you wrote in the first worksheet, although today's
+ class should allow you to write something a bit more elegant)
+
+## Towards object-oriented programming
+
+During play, the secret isn't supposed to change (or the game would become
+suddenly much more difficult…). It is therefore a bit awkward to have to pass
+the `secret` argument every time the function is called. Let's create a class to
+hold the contextual information that this `secret` is and make it available to
+our function!
+
+- create a new class called `Game` in a new file called `Game.java` in an empty
+ directory.
+- make sure it has an `int` field to hold the `secret` that will replace the
+ corresponding variable
+- implement its constructor
+- now reuse and adapt the code of the previous function to become a method in
+ this new `Game` class.
+
+Please note that even though a bit long, classes can still be evaluated by
+`jshell`. With all the structure we have designed so far, playing should have
+become as easy as:
+
+1. Starting a game with `Game game = new Game(<SOME SECRET HERE>);`
+2. Try a number with `game.guess(13)` (assuming you have named your function
+ `guess`)
+3. Repeating step 2. adjusting your guess based on the feedback provided.
+
+Once it works in `jshell`, make sure the class file also compiles with `javac`.
+
+Ok, not bad but usually when we play a game we don't have to manually type
+commands to a Java prompt. Please meet the `Scanner`
+class ([https://docs.oracle.com/en/java/javase/19/docs/api/java.base/java/util/Scanner.html](https://docs.oracle.com/en/java/javase/19/docs/api/java.base/java/util/Scanner.html))
+
+- read about it, look at the examples provided
+- try and reproduce them in jshell
+- pay attention to what happens when the input doesn't represent a proper
+ integer: what feature covered in today's class could help us handle that?
+- once you're confortable enough with this new tool, turn it into a new method
+ of your `Game` class called `prompt`. Does it need to access any context?
+ Should you make it `static` or not?
+- get rid of `guess`'s last parameter and call the new `prompt` method instead
+ to declare the (local) variable
+
+Keep checking everything still compiles (hint: need an import? look at the
+documentation). Next step will be to have Java call this method automatically in
+a loop but… wait! How can we know when to stop?
+
+- alter the type of your method to provide enough information to its caller to
+ know whether to stop or continue
+- check it works by writing a very simple (so simple it may look suspicious)
+ loop using it in `jshell`
+
+## A command-line program
+
+Now that we have all the logics for the game in a class, let's expose it as a
+command-line program to start the game.
+
+- Create an empty `Main` class in a new `Main.java` file holding the structure
+ for an empty program (draw inspiration from the last section of the slides).
+ Verify you can compile it with `javac` and run it with `java`
+- Running the game should be just: instanciating a new `Game`, then using it in
+ the same loop you have been practicing at the end of the previous part.
+ Implement the `main` function accordingly
+
+We have made a very simple game!
+
+## Suggested improvements
+
+- the secret value is so far built into your game, once someone has guessed
+ it it has solved the game once and for all. Let's make the game a little bit
+ more interesting by having *the computer* choose the `secret` itself. Please
+ meet the `Random` class
+ ([https://docs.oracle.com/en/java/javase/19/docs/api/java.base/java/util/Random.html](https://docs.oracle.com/en/java/javase/19/docs/api/java.base/java/util/Random.html))
+- again: try in `jshell`, look at the results returned, how could we leverage
+ that into something usable for our game?
+- replace your built-in secret by a random one
+
+One last thing: the range on which you play is still arbitrary. Let's replace
+that by a parameter on the command line.
+
+- modify the `main` function of your class to
+ + make sure only one argument is passed to your program
+ + convert it to an `int`, not forgetting to handle the errors which may
+ arise
+ + use this value as the upper bound for your random number
+
+We're done! We have an actually playable game, and it doesn't require its users
+to type Java or to know anything about the `jshell`.
+
+# Extra fun for the Java enthuasiast
## Namespace occupation
+### First draft
+
The euclidian norm in a 2D-space ("plane") can be defined as a function of the
coordinates $(x_A, y_A)$ of a given point $A$.
@@ -41,28 +133,26 @@ $\sqrt{2} \approx 1.414$).
Now, let's define the same function but for a 3D-space. Can you keep the same
name ? What do you suggest ?
-# Objects
+### Sharing the namespace
-## Sharing the namespace
-
-### 2D-Points
+#### 2D-Points
- Declare a simple class `Point2D` to model a geometric point in the plane (2D
space). What fields must it contain ? What type will you use for them ?
- Add a `norm` method to compute the same metric as previously. How will the
signature differ from the signature of the function defined above ?
-### 3D-Points
+#### 3D-Points
- Now create a new class to represent points in a 3D space.
- Add the corresponding `norm` method to it too. Is there any naming conflict ?
## Pass by value / pass by reference
-- Declare an `short` value `age` and assign it to `4`.
-- Create a (`void`) function called `increment` that increases the value of its
+- Declare a `short` value `age` and assign it to `4`.
+- Create a (`void`) procedure called `increment` that increases the value of its
only (`short`) argument by `1` (modifies it without returning it).
-- Apply it on `age`. Did you get any error ? Was `age` modified ?
+- Apply it on `age`. Did you get any error? Was `age` modified?
A native value is nothing more than a (temporary) value in the processor.
There's no memory location available. When a function is called in Java, it is
@@ -71,8 +161,8 @@ simpler and closer to the mathematical intuition of functions, but it can be
costly for huge data structures.
We're now going to define a special wrapper for the `short` type where we have
-access to the inner value : `RWShort`. This class should have one field of type
-`short` named `value`.
+access to the inner value : `RWShort` ("read-write short"). This class should
+have one field of type `short` named `value`.
- Declare a `RWShort` value called `rwAge` holding the same value `4`.
- Modify `increment` so that it now works on `RWShort` and not `short`
@@ -80,7 +170,10 @@ access to the inner value : `RWShort`. This class should have one field of type
Java passes arguments by value; but since the value of objects are their
reference in memory, this actually amounts to passing by reference ! We get the
-best of both worlds.
+best of both worlds. Again, understanding the duality in Java datastructures
+between "what is directly a number" and "what is a complex data implented by a
+graph of number values" helps us understand why things are working the way they
+do.
## Automatically numbering instances with `static`
@@ -96,22 +189,3 @@ best of both worlds.
This pattern can be very useful to keep track of objects created throughout an
application.
-
-# Executable code
-
-You will now create your first command-line program.
-
-- Create an empty `Main` class holding the structure for an empty program (draw
- inspiration from the last section of the slides).
-- Now add a method to this class using the code from the function defined in the
- first exercise ("Collatz returns !"). Should this method be `static` or not ?
-- Which `static` method from the `Integer` class lets one convert a `String` to
- an `int` value ? Read its documentation to understand what happens when its
- argument doesn't represent a number.
-- Modify the `main` function of your class to
- + make sure only one argument is passed to your program
- + convert it to an `int` and don't forget to handle the errors which may arise
- + pass it to the collatz method you've imported
-- Compile and run your program from a shell: you now have an executable which
- can display the Collatz sequence from a number passed to it, and it doesn't
- require its users to type Java or to know anything about the `jshell`.
diff --git a/Worksheet/Worksheet3.md b/Worksheet/Worksheet3.md
index 9659f278b31ffd97cf4ea8c6e44cb016305f74a9..ead044b95d12a30df3db9fcb23caa0f6eaee49fc 100644
--- a/Worksheet/Worksheet3.md
+++ b/Worksheet/Worksheet3.md
@@ -2,215 +2,154 @@
title: Worksheet 3
---
-# A little cryptography
-
-## Caesar
-
-Remember *Rot13* from [Worksheet
-1](https://perso.liris.cnrs.fr/abrenon/no-backup/Worksheet1.pdf) ? It is a
-substitution cipher said to have been invented by the roman emperor Caesar which
-consists in shifting the letters in the source message, starting over from 'A'
-if a letter "greater than" 'Z' is needed. Caesar is said to have always shifted
-the letters by 13 ranks in the alphabet, making the process an involution: with
-this value for the key, encoding and decoding become the same process (because
-$13 + 13 = 26 \equiv 0 [26]$, total number of letters in the latin alphabet). In
-practice other values can be used as long as the sender and recipient agree on
-it and this choice acts as a "key": a secret protecting the original text and
-allowing to retrieve it. For instance, let us use the key $6$ on some input
-message:
-
-`"CRASSUS IS DUMB"`
-
-$\hspace{1cm}\downarrow + 6$
-
-`"IXGYYAY OY JASH"`
-
-Decoding is then performed substracting the key instead of adding it (or,
-equivalently, adding its complement to 26, here $26 - 6 = 20$). Starting from
-your previous implementation (or over if you skipped it) in Worksheet 1
-generalize it into a function `caesar` taking the key and the source message as
-inputs and returning the encrypted text.
-
-### Design
-
-- How will you name its arguments ?
-- Last time, we had only printed the encrypted message on the console (`stdout`
- with `System.out.println`) but now we want to be able to handle the returned
- value. What should its signature be ?
-
-
-### Implementation
-
-Remember that we can't modify characters in a `String`.
-
-- What other data structure can we use internally during the encryption /
- decryption process and eventually convert to `String` ?
-- How to create it ?
-- How to access its individual characters ?
-- How to retrieve a `String` from it ?
-
-Look up the documentation (or the slides from class 2) if you don't remember.
-Also, keep in mind that Caesar's cipher is only concerned with letters and
-ignores spaces which were probably not considered as proper characters at the
-time. Make sure your function leaves all non-alphabetical characters unchanged.
-
-Test it with the above message, manually passing it a key or its opposite to
-encrypt or decrypt. Check that *Rot13* is an involution, i.e., that using key
-`13`, you can decrypt a message by re-encrypting it as if it were a plain text.
-
-## Vigenère
-
-In practice, Caesar's cipher is very weak because there are only 25 possible
-keys, and since it keeps the statistical repartition of letters unchanged, in
-particular double letters, it is reasonably easy to break it without even trying
-all of them. Another classic substitution method, called the *Vigenère* cipher,
-addresses this issue. You can view it as a kind of Caesar where the offset
-changes for each letter. In practice, the lists of different offsets (looped
-when the source message is longer) is memorized through its alphabetic
-equivalent, becoming a textual key instead of a numeric one. For instance, the
-key "BRUTUS" may be used on the previous message, meaning that the first letter
-should be offset by 2 (the rank of 'B' is 2), the second one by 18, third by 21… and
-looping to 2 for the seventh letter.
-
-`"CRASSUS IS DUMB"`
-
-$\hspace{1cm}+$
-
-`"BRUTUSB RU TUSB"`
-
-$\hspace{1cm}\downarrow$
-
-`"EJVMNNU AN XPFD"`
-
-### Design
-
-- How will the names of the arguments for this new function differ from the
- previous one ?
-- How about their types ?
-
-### Implementation time !
-
-- What is the major difference with `caesar`'s implementation ?
-- What additional local variable will you need to represent this ?
-- Remember how we left non-alphabetical characters out in `caesar` ? There are
- two ways to "align" the looped key in `vigenere` : including the unchanged
- characters or not. In the example above we have chosen to align the key with
- the transformed characters only. Make sure you follow this convention in your
- implementation.
-
-## Factorizing
-
-Both being substitution ciphers, there should be similarities in the above
-functions. What could be shared between `caesar` and `vigenere` ?
-
-Factorize those bits into subfunctions. Check that your code still works. In
-particular, `vigenere` should allow you to reproduce what you could already do
-with `caesar` (*Rot13* is just *Vigenere* cipher with key `"M"`).
-
-What are the remaining similarities between both functions ? Can we factorize
-them any further ?
-
-# Structuring
-
-The concept of inheritance we have covered today allows us to capture similar
-behaviours and share parts of the implementation. In addition, having objects
-exposing the previous functionalities will easily take care of the notion of
-state that needed to be maintained during the computations.
-
-## Declare an interface
-
-First it can be useful to underline the "common shapes" between two classes and
-name them. This will allow us to handle various ciphers in the same way later in
-the code.
-
-- Create an interface called `Cipher` representing the ability to both
- encrypt and decrypt messages.
-- What should be the signatures of the corresponding methods ?
-
-## A common behaviour
-
-- We have called both *Caesar* and *Vigenère* "substitution" ciphers. This will
- reflect on our code as an abstract class: saying a cipher belongs to this
- family means they it will share a common behaviour with them (namely, that it
- ciphers characters separately and that the image of each will depend on its
- rank in the alphabet). Create this class named `Substitution`.
-- In the previous factorization process, you should have created a function
- performing the shift of individual characters. Create the corresponding method
- on your class. Should it be `static` or not ? What will be the implications ?
-- To generalize substitution ciphers, we need to say that they have a specific
- (`int`) offset which can change over the execution (constant for *Caesar* but
- looping over the key in *Vigenère*. Add a corresponding `abstract protected
- int` method to your class (its state is tied to a particular instance of the
- class which is why it should not be `static`)
-- In the first part, we noticed that encrypting and decrypting was basically the
- same operation, only affecting the way they key was applied (added or
- substracted). Implement this general process as a common method taking a
- factor of `+1` or `-1` as argument. What visibility should it have ?
-- Implement both `encrypt` and `decrypt` for `Substitution` using this
- additional method. This was the structure which we hadn't been able to
- factorize at the end of the previous part.
-
-## Inheriting
-
-- Inheriting the above `abstract class`, implement both `Caesar` and `Vigenere`
-- See how their implementation becomes mostly "administrative" tasks handling
- their respective internal states to align with the common behaviour captured
- by `Substitution` ?
-
-# A usable tool
-
-Let us now package the above into a proper command line ciphering suite.
-
-## The logic
-
-- We will call our tool `i4j-crypto` and package its logic as a library under
- the virtual path `fr.insa_lyon.ist_4_jav.crypto`. Create the empty folder
- structure for it.
-- Create a file for each of the above entity (interface and classes) and fill it
- with the code you've written in the previous part.
-- Don't forget to add the appropriate `package` mentions
-- What about the visibility ? Which interface or classes need to be `public` ?
- Can they be `private` or `protected` ? Why ? What would be the implication of
- the abstract class `Substitution` not being `public` ?
-
-## The tool
-
-- Create an empty `Main` class with the appropriate `main` method.
-- Check that everything compiles.
-
-## Design
-
-We propose the following syntax for our tool:
-
-```bash
-i4j-crypto [caesar|vigenere] -k <KEY> [-e|-d] <MESSAGE>
-```
-
-meaning that the command should be followed either by the mode name `caesar` or
-`vigenere`, then by the option `-k` with a key as argument and finally by either
-the `-e` or `-d` flag (respectively to make the program encrypt or decrypt the
-remaining `<MESSAGE>` text).
-
-- Edit your `main` function so that it enforces the above behaviour, printing
- helpful error messages and exiting with status `1` when it detects an invalid
- syntax (see `System.exit`).
-- In particular, pay attention to fact that depending on the cipher used, the
- `<KEY>` argument should be handled as an integer or a text.
-
-## Wiring it all
-
-- Add the `import` statement required in the `Main` class to show that it is
- using our cryptographic library.
-- Now handle the correct cases by creating a `Cipher` variable while parsing the
- command line and finally calling its `encrypt` or `decrypt` method, depending
- on the value of the corresponding flag. See how having a common type thanks to
- the `Cipher` interface simplifies our code ?
-- Most command-line tools display their syntax and available options when
- started with the `--help` (or `-h`) flag. This is useful for people
- discovering new tools to understand what they expect and how they are supposed
- to work. Handle this new special cases.
-- Test your tool to encrypt and decrypt messages with the people around you in
- class.
-- You can create another "entry point" (main class) to your program performing
- several encryption, decryption, or mix thereof one after another. Notice any
- bug(s) ? How could we modify the previous implementation(s) to fix them ?
+# Object design
+
+In this section we will focus on class design to model objects for a
+game.
+
+## Pokemons
+
+Suppose we want to implement a pokemon game in Java. You probably already know
+the game but just in case, know that Pokemons are creatures which develop and
+grow: they gain experience, or "XP", which accumulate until they have enough to
+gain a new "level" (a baby pokemon starts at level 1 and can climb all the way
+to level 100, where they remain forever — but in earlier versions of the game,
+some glitches allowed to encounter pokemons of a level higher than 100, but
+always strictly inferior to 255… if you managed to catch one and won a fight
+with them they would immediately revert to level 100 or 1, different accounts by
+different people gave different, hard to know which one was true if any, given
+how easily a level 248 pokemon would effortlessly distroy all your team of
+pokemons but I digress).
+
+How would you describe one particular species, say Lapras?
+
+- create a new class in an empty file named `Lapras.java`, to represent the
+ species itself, from which particular individual pokemons, the *instances* of
+ the class will be made
+- think about the fields you need a pokemon to have: how would you name them,
+ what types should they be?
+- implement a first constructor for the class
+
+Each individual has a name which is by default the name of its species, but
+which can be altered later in the game
+
+- modify the fields in your `Lapras` class to support the name and the
+ constructor accordingly
+
+New individuals of a given species are created in the game
+ + as babies when a pokemon cracks its egg
+ + as a wild pokemon of a given level, usually randomized in a range
+ depending on the geographical zone within the game
+
+- modify the existing constructor accordingly and add a new one to support this
+ new possibility
+
+To gain experience pokemons fight, by throwing attacks at each others ("moves"
+in Pokemon parlance) which can directly hurt the opponent or have various
+effects on the game such as modifying their own status or the opponent's in good
+or in bad (there are several different ways to boost a pokemon or to reduce its
+abilities, to make it sleep, or burn, or be poisoned…). We won't go into to much
+detail about implementing attacks at first.
+
+- create a class `Move` in a new `Move.java` file. Let's say for now that an
+ attack is defined by its name, the damages it does and a possible effect,
+ which will only be printed to the player for now. Add the corresponding fields
+ and constructors
+
+It should be noted that as they grow pokemon acquire new attacks based on their
+level (each species spontaneously learns each move it can learn when it reaches
+a specific level: for instance, all pokemons of the same species might learn say
+`growl` at level 7, `byte` at level 15 and `heal` at level 27). But at any time,
+a pokemon cannot know more than 4 moves (it can know less and often starts with
+only 1 or 2 moves).
+
+- how could we represent such a piece of data (the levels at which a given
+ species will try and learn new moves)?
+- is that a trait tied to each individual or to the species itself? As a
+ consequence, would you make this property in the class `static` or not?
+- implement a list of attacks for `Lapras` to learn based on the game data
+
+Oh, and there are elemental types too: water - fire - plant — ground - rock -
+eletrik (yeah they spelt it that way, go figure…), psy… and a bunch of others
+which you can probably look online. There is a intricate algebra of
+efficiency/resistence a bit like rock/paper/scissors but on steroids. You can
+probably look it up too, but it changed slightly across the versions so don't
+worry too much about it, just pick the types you want to support and try to get
+some more or less plausible efficiencies (if water doesn't extinguish fire which
+burns plant which absorb water, I don't wanna play your game…). We will see in
+next class a good feature of Java to represent (pokemon) types, so you can just
+use `String` for now.
+
+- make a new class in a separate file to handle types. Again, don't worry too
+ much about their representation, but just focus on exposing the required
+ logic: how efficient an attack of a given type is on a pokemon based on its
+ type
+
+Each move has an associated type, and each pokemon species also has at least one
+type, and can have up to two. They needn't always align — most pokemons learn
+"normal" type moves, and can sometimes learn a couple moves out of their type.
+
+- `Lapras` is type "water", so modify the class accordingly — again, ask
+ yourself whether this should be a property of each individual or of the
+ species as a whole and pick the field modifiers accordingly
+- modify the `Move` class too to add a type
+
+Ok, so far, we have done only composition by adding field of a given class to
+another class, but it's high time we enriched our game with other species (there
+are hundreds of them after all). Let's say we want to have `Pikachu` and
+`Raichu`.
+
+- we are certainly not going to reimplement everything we did for `Lapras` into
+ each of the new classes: let's take all the properties they should share into
+ a mother `Pokemon` class which all pokemon species should *extend*. Create a
+ new file for the class accordingly
+- would it actually make sense to instanciate a `Pokemon` out of any particular
+ species? So what keyword should you use on that class?
+- move all the code you want to share between your species into the new class
+- which common property or behaviour custom to each species should you leave
+ unimplemented? How would you do so?
+
+Finally pokemons "evolve": a given species will spontaneously turn into another
+one when certain conditions are met. Most of the time, reaching a given level is
+enough (and then, if evolution is blocked it will retry at each new level), but
+sometimes a particular object (an evolution stone) is required as is the case
+for a `Pikachu` to become a `Raichu`.
+
+- update the `Pokemon` class to take this new ability into account
+- update the implementations of `Lapras`, `Pikachu` and `Raichu` to reflect the
+ fact that both `Lapras` and `Raichu` can't evolve, but that `Pikachu` can turn
+ into a `Raichu` when given a thunder stone.
+- so in a sense, an individual pokemon can switch species (when evolving), even
+ though it keeps all the moves it already knows. What would be the best way to
+ represent this? There's not necessarily a best way to do so, maybe we could
+ add a new constructor to the evolved species taking an instance of the base
+ species as argument, or maybe we should entirely decorelate individuals from
+ their species, and use composition: maybe the species of a pokemon should have
+ been only one field in a pokemon among others?
+
+# Packaging
+
+Now, the model described above will be used to implement a version of the game
+itself, but it could also be extremely useful to create tools to help players
+learn about the game, optimize their strategies, so that it could make sense to
+expose the data encoded within the library as a web API.
+
+For that reason, we are going to create a separate package for the pokemon
+library encoding the game data, and other packages for the game and the API.
+
+- create the corresponding structure in the directory where you work for this
+ practice
+- move the files you've already created to the right place.
+
+Let's start implementing tools
+
+- make a new executable program (`Main` class, `main` entry point etc.)
+ leveraging the library to create a couple pokemons and make them fight,
+ ideally with some interaction from the user if you want your program to look
+ like a game (choose a move, see the result, handle damage…)
+- make another executable to query information about the various species, taking
+ simple queries as input and displaying the relevant information extracted from
+ the library
+- in the process, you should notice everything that you need to expose and
+ modify the visibility of the various fields you've introduced in your code
+ accordingly
diff --git a/Worksheet/Worksheet4.md b/Worksheet/Worksheet4.md
index ec68320e6360854fc33f1953bd1e5d974dbb6c15..85d213d9921b00b5347b94f1794adb6ecddb0e43 100644
--- a/Worksheet/Worksheet4.md
+++ b/Worksheet/Worksheet4.md
@@ -21,16 +21,16 @@ long fibonacci(int n);
- Test your function on "small" inputs ($< 10$). Now use it to find the value of
$f_{40}$ and note the time it takes. Try `45` if you're feeling particularly
- daring today. What is going on ?
+ daring today. What is going on?
## Let's add some logging
- Modify the previous function to log its argument each time it is called.
-- Retry the previous calls with the small values. What do you notice ?
+- Retry the previous calls with the small values. What do you notice?
## Keeping answers
-A simple way to address the issue we have just underlined is *memoization*: we
+A simple way to address the issue we have just evidenced is *memoization*: we
trade a little space (in memory) against some time (to run the algorithm). If
our program could somehow "remember" the answers it gives it wouldn't have to
compute the same sums over and over.
@@ -50,8 +50,8 @@ compute the same sums over and over.
compute the sum and store it only in that case, and finally return the content
of the cache.
- Compute values you've computed before to check the results. What do you
- observe regarding logging messages ? In particular, what happens when you
- compute the same term twice ?
+ observe regarding logging messages? In particular, what happens when you
+ compute the same term twice?
# Graphical User Interface
@@ -95,7 +95,7 @@ should inherit `JSpinner`.
`Integer` variables as above, initialize them with sensible values, and return
a call to the constructor for `SpinnerNumberModel` on the four previous
variables. Why can the method return type `SpinnerModel` and not
- `SpinnerNumberModel` (type returned by the call to the constructor) ?
+ `SpinnerNumberModel` (type returned by the call to the constructor)?
- Implement `FiboInput`'s constructor by simply passing the result of `getRange`
to the `super` constructor.
- We can go back to `createAndShowGUI`, add a `FiboInput` variable called
@@ -116,7 +116,7 @@ should inherit `JSpinner`.
stateChanged(ChangeEvent e)` method. Add one to the class and have it log the
event `e` to the console. Register it to the Swing engine by calling the
`addChangeListener` on `super` in the constructor. What argument should be
- passed to this method ?
+ passed to this method?
- Recompile your application, run it, play with the number input and look at the
lines getting logged to the console.
- Now we'd like something more useful to happen when the value is changed: we'll
@@ -128,10 +128,11 @@ should inherit `JSpinner`.
`FiboInput` properly.
- All that remains is to have the handler use `Fibonacci.get` from the first
part. Retrieve the rank from the value of the `FiboInput` (remember:
- `FiboInput` is a `JSpinner`, we made it inherit the class for this reason !
- what method could be useful to retrieve its current value ? read the
- documentation carefully: what type does it return ? what could we do about it
+ `FiboInput` is a `JSpinner`, we made it inherit the class for this reason!
+ what method could be useful to retrieve its current value? read the
+ documentation carefully: what type does it return? what could we do about it
?). Pass it to `Fibonacci.get`, convert the (`long`) result to `String` and
set the output to that.
-Recompile everything. We got ourselves a simple Fibonacci sequence calculator !
+Recompile everything. We got ourselves a simple but efficient Fibonacci sequence
+calculator!