+
+
+
+## What implicit requirements do audiences have?
+
+Software engineers design systems for all kinds of people, from all parts of the world, with all kinds of needs.
+Often some people have requirements that are _implicit_, yet are just as required as the requirements they will explicitly tell you about.
+Concretely, we will see _localization_, _internationalization_, and _accessibility_.
+Sometimes these are shortened to ""l10n"", ""i18n"", and ""a11y"", each having kept their start and end letter, with the remaining letters being reduced to their number.
+For instance, there are 10 letters between ""l"" and ""n"" in ""localization"", thus ""l10n"".
+
+_Localization_ is all about translations. Users expect all text in programs to be in their language, even if they don't explicitly think about it.
+Instead of `print(""Hello "" + user)`, for instance, your code should use a constant that can be changed per language.
+It is tempting to have a `HELLO_TEXT` constant with the value `""Hello ""` for English, but this does not work for all languages because text might also come after the user name, not only before.
+The code could thus use a function that takes care of wrapping the user name with the right text: `print(hello_text(user))`.
+
+Localization may seem simple, but it also involves double-checking assumptions in your user interface and your logic.
+For instance, a button that can hold the text ""Log in"" may not be wide enough when the text is the French ""Connexion"" instead.
+A text field that is wide enough for each of the words in ""Danube steamship company captain"" might overflow with the German ""Donaudampfschifffahrtsgesellschaftkapitän"".
+Your functions that provide localized text may need more information than you expect.
+English nouns have no grammatical gender, so all nouns can use the same text, but French has two, German has three, and Swahili has [eighteen](https://en.wikipedia.org/wiki/Swahili_grammar#Noun_classes)!
+English nouns have one ""singular"" and one ""plural"" form, and so do many languages such as French, but this is not universal; Slovenian, for instance, has one ending for 1, one for 2, one for 3 and 4, and one for 5 and more.
+
+Translations can have bugs just like software can.
+For instance, the game Champions World Class Soccer's German translation infamously has a bug in which ""shootout"" is not, as it should, translated to ""schiessen"",
+but instead to ""scheissen"", which has an entirely different meaning despite being one letter swap apart.
+Another case of German issues is [in the game Grandia HD](https://www.nintendolife.com/news/2019/08/random_amazingly_grandia_hds_translation_gaffe_is_only_the_second_funniest_german_localisation_mistake):
+missing an attack displays the text ""fräulein"", which is indeed ""miss"" but in an entirely different context.
+
+Localization is not something you can do alone unless you are translating to your native language, since nobody knows all features of all languages.
+Just like other parts of software, localization needs testing, in this case by native speakers.
+
+_Internationalization_ is all about cultural elements other than language.
+Consider the following illustration:
+
+Example solutions (click to expand)
++ +A course registration system could have students, which are entities identified by a university e-mail who have a list of courses and grades associated with the courses, and +lecturers, which are associated with the courses they teach and can edit said courses. Courses themselves might have a name, a code, a description, and a number of credits. + +Some testing scenarios might be ""given that a user is already enrolled in a course, when the user tries to enroll again, then that has no effect"", or ""given that a lecturer +is in charge of a course, when the lecturer sets grades for a student in the course, then that student's grade is updated"". + +
+
+
+
+---
+
+
+Overall, names are a tool to make code clear and succinct, as well as consistent with other code so that readers don't have to explicitly think about names.
+
+### Documentation
+
+_Documentation_ is a tool to explain _what_ a piece of code does.
+
+Documentation is the main way developers learn about the code they use. When writing code, developers consult its documentation comments, typically within an IDE as tooltips.
+Documentation comments should thus succinctly describe what a class or method does, including information developers are likely to need such as whether it throws exceptions,
+or whether it requires its inputs to be in some specific format.
+
+### Comments
+
+_Comments_ are a tool to _why_ a piece of code does what it does.
+Importantly, comments should not say _how_ a piece of code does what it does, as this information already exists in the code itself.
+
+Unfortunately, not all code is ""self-documenting"".
+Comments are a way to explain tricky code.
+Sometimes, code has to be written in a way that looks overly complicated or wrong because the code is working around some problem in its environment, such as a bug in a library,
+or a compiler that only produces fast assembly code in specific conditions.
+
+Consider the following good example of a comment, taken from an old version of the Java development kit's `libjsound`:
+
+```c
+/* Workaround: 32bit app on 64bit linux gets assertion failure trying to open ports.
+ Until the issue is fixed in ALSA (bug 4807) report no midi in devices in the configuration. */
+if (jre32onlinux64) { return 0; }
+```
+
+This is a great example of an inline comment: it explains what the external problem is, what the chosen solution is, and refers to an identifier for the external problem.
+This way, a future developer can look up that bug in ALSA, a Linux audio system, and check if was fixed in the meantime so that the code working around the bug can be deleted.
+
+Inline comments are a way to explain code beyond what code itself can do, which is often necessary even if it ideally should not be.
+This explanation can be for the people who will review your code before accepting your proposed changes, or for colleagues who will read your code when working on the codebase months later.
+Don't forget that one of these ""colleagues"" is likely ""future you"". No matter how clear you think a piece of code is right now, future you will be grateful for comments that explain the non-obvious parts.
+
+### Formatting
+
+Formatting code is all about making it easier to read code. You don't notice good formatting, but you do notice bad formatting, and it makes it harder to focus.
+
+Here is a real world example of bad formatting:
+
+```c
+if (!update(&context, ¶ms))
+ goto fail;
+ goto fail;
+```
+
+Did you spot the problem? The code looks like the second `goto` is redundant, because it's formatted that way.
+But this is C. The second `goto` is actually outside of the scope of the `if`, and is thus always executed.
+This was a real bug that triggered [a vulnerability](https://nakedsecurity.sophos.com/2014/02/24/anatomy-of-a-goto-fail-apples-ssl-bug-explained-plus-an-unofficial-patch/) in Apple products.
+
+Some languages enforce at least some formatting consistency, such as Python and F#. But as you saw with the `planets.py` exercise earlier, that does not mean it's impossible to format one's code poorly.
+
+### Consistency
+
+Should you use `camelCase` or `snake_case` for your names? 4 or 8 spaces for indentation? Or perhaps tabs? So many questions.
+
+This is what _conventions_ are for. The entire team decides, once, what to do.
+Then every member of the team accepts the decisions, and benefits from a consistent code style without having to explicitly think about it.
+
+Beware of a common problem called _bikeshedding_ when deciding on conventions.
+The name comes from the story illustrating it: a city council meeting has two items on the agenda, the maintenance of a nuclear power plant and the construction of a bike shed.
+The council quickly approves the nuclear maintenance, which is very expensive, because they all agree that this maintenance is necessary to continue to provide electricity to the city.
+Then the council spends an hour discussing the plans for the bike shed, which is very cheap. Isn't it still too expensive? Surely the cost can be reduced a bit, a bike shed should be even cheaper.
+Should it be blue or red? Or perhaps gray? How many bikes does it need to contain?
+It's easy to spend lots of time on small decisions that ultimately don't matter much, because it's easy to focus on them.
+But that time should be spent on bigger decisions that are more impactful, even if they are harder to discuss.
+
+Once you have agreed on a convention, you should use tools to enforce it, not manual efforts.
+Command-line tools exist, such as `clang-format` for C code, as well as tools built into IDEs, which can be configured to run whenever you save a file.
+That way, you no longer have to think about what the team's preferences are, tools do it for you.
+
+
+## How can one efficiently debug a program?
+
+Your program just got a bug report from a user: something doesn't work as expected. Now what?
+The presence of a bug implies that the code's behavior doesn't match the intent of the person who wrote it.
+
+The goal of _debugging_ is to find and fix the _root cause_ of the bug, i.e., the problem in the code that is the source of the bug.
+This is different from the _symptoms_ of the bug, in the same way that symptoms of a disease such as loss of smell are different from a root cause such as a virus.
+
+You will find the root cause by repeatedly asking ""_why?_"" when you see symptoms until you get to the root cause.
+For instance, let's say you have a problem: you arrived late to class.
+Why? Because you woke up late.
+Why? Because your alarm didn't ring.
+Why? Because your phone had no battery.
+Why? Because you forgot to plug your phone before going to sleep.
+Aha! That's the cause of the bug. If you had stopped at, say, ""your alarm didn't ring"", and tried to fix it by adding a second phone with an alarm, you would simply have two alarms that didn't ring,
+because you would forget to plug in the second phone as well.
+But now that you know you forgot to plug in your phone, you can attack the root cause, such as by putting a post-it above your bed reminding you to charge your phone.
+You could in theory continue asking ""why?"", but it stops being helpful after a few times.
+In this case, perhaps the ""real"" root cause is that you forget things often, but you cannot easily fix that.
+
+At a high level, there are three steps to debugging: reproduce the bug, isolate the root cause, and debug.
+
+Reproducing the bug means finding the conditions under which it appears:
+- What environment?
+ Is it on specific operating systems? At specific times of the day? In specific system languages?
+- What steps need to be taken to uncover the bug?
+ These could be as simple as ""open the program, click on the 'login' button, the program crashes"", or more complex, such as creating
+ multiple users with specific properties and then performing a sequence of tasks that trigger a bug.
+- What's the expected outcome? That is, what do you expect to happen if there is no bug?
+- What's the actual outcome? This could be simply ""a crash"", or it could be something more complex, such as ""the search results are empty even though there is one item matching the search in the database""
+- Can you reproduce the bug with an automated test? This makes it easier and less error-prone to check if you have fixed the bug or not.
+
+Isolating the bug means finding roughly where the bug comes from.
+For instance, if you disable some of your program's modules by commenting out the code that uses them, does the bug still appear? Can you find which modules are necessary to trigger the bug?
+You can also isolate using version control: does the bug exist in a previous commit? If so, what about an even older commit? Can you find the one commit that introduced the bug?
+If you can find which commit introduced the bug, and the commit is small enough, you have drastically reduced the amount of code you need to look at.
+
+Finally, once you've reproduced and isolated the bug, it's time to debug: see what happens and figure out why.
+You could do this with print statements:
+```c
+printf(""size: %u, capacity: %u\n"", size, capacity);
+```
+However, print statements are not convenient. You have to write potentially a lot of statements, especially if you want to see the values within a data structure or an object.
+You may not even be able to see the values within an object if they are private members, at which point you need to add a method to the object just to print some of its private members.
+You also need to manually remove prints after you've fixed the bug.
+Furthermore, if you realize while executing the program that you forgot to print a specific value, using prints forces you to stop the program, add a print, and run it again, which is slow.
+
+Instead of print statements, use a tool designed for debugging: a debugger!
+
+### Debuggers
+
+A debugger is a tool, typically built into an IDE, that lets you pause the execution of a program wherever you want, inspect what the program state is and even modify the state,
+and generally look at what a piece of code is actually doing without having to modify that piece of code.
+
+One remark about debuggers, and tools in general: some people think that not using a tool, and doing it the ""hard"" way instead, somehow makes them better engineers.
+This is completely wrong, it's the other way around: knowing what tools are available and using them properly is key to being a good engineer.
+Just like you would ignore people telling you to not take a flashlight and a bottle of water when going hiking in a cave, ignore people who tell you to not use a debugger or any other tool you think is useful.
+
+Debuggers also work for software that runs on other machines, such as a server, as long as you can launch a debugging tool there, you can run the graphical debugger on your machine to debug a program on a remote machine.
+There are also command-line debuggers, such as `jdb` for Java or `pdb` for Python, though these are not as convenient since you must manually input commands to, e.g., see what values variables have.
+
+The one prerequisite debuggers have is a file with _debug symbols_: the link between the source code and the compiled code.
+That is, when the program executes a specific line of assembly code, what line is it in the source code? What variables exist at that point, and in which CPU registers are they?
+This is of course not necessary for interpreted languages such as Python, for which you have the source code anyway.
+It is technically possible to run a debugger without debug symbols, but you then have to figure out how the low-level details map to high-level concepts yourself, which is tedious.
+
+Let's talk about five key questions you might ask yourself while debugging, and how you can answer them with a debugger.
+
+_Does the program reach this line?_
+Perhaps you wonder if the bug triggers when a particular line of code executes.
+To answer this question, use a _breakpoint_, which you can usually do by right-clicking on a line and selecting ""add a breakpoint"" from the context menu.
+Once you have added a breakpoint, run the program in debug mode, and execution will pause once that line is reached.
+Debuggers typically allow more advanced breakpoints as well, such as ""break only if some condition holds"", or ""break once every N times this line is executed"".
+
+You can even use breakpoints to print things instead of pausing execution.
+Wait, didn't we just say prints weren't a good idea? The reason why printing breakpoints are better is that you don't need to edit the code, and thus don't need to revert those edits later,
+and you can change what is printed where while the program is running.
+
+_What's the value of this variable?_
+You've added a breakpoint, the program ran to it and paused execution, now you want to see what's going on.
+In an IDE, you can typically hover your mouse over a variable in the source code to see its value while the program is paused, as well as view a list of all local variables.
+This includes the values within data structures such as arrays, and the private members in classes.
+You can also execute code to ask questions, such as `n % 12 == 0` to see if `n` is currently a multiple of 12, or `IsPrime(n)` if you have an `IsPrime` method and want to see if what it returns for `n`.
+
+_What if instead...?_
+You see that a variable has a value you didn't expect, and wonder if the bug would disappear if it had a different value.
+Good news: you can try exactly that. Debuggers typically have some kind of ""command"" window where you can write lines such as `n = 0` to change the value of `n`, or `lst.add(""x"")` to add `""x""` to the list `lst`.
+
+_What will happen next?_
+The program state looks fine, but maybe the next line is what causes the problem?
+""Step"" commands let you execute the program step-by-step, so that you can look at the program state after executing each step to see when something goes awry.
+""Step into"" will let you enter any method that is called, ""step over"" will go to the next line instead of entering a method, and ""step out"" will finish executing the current method.
+Some debuggers have additional tools, such as a ""smart"" step that only goes inside methods with more than a few lines.
+Depending on the programming language and the debugger, you might even be able to change the instruction pointer to whichever line of code you want, and edit some code on the fly without having to stop program execution.
+
+Note that you don't have to use the mouse to run the program and run step by step: debuggers typically have keyboard shortcuts, such as using F5 to run, F9 to step into, and so on, and you can usually customize those.
+Thus, your workflow will be pressing a key to run, looking at the program state after the breakpoint is hit, then pressing a key to step, looking at the program state, stepping again, and so on.
+
+_How did we get here?_
+You put a breakpoint in a method, the program reached it and paused execution, but how did the program reach this line?
+The _call stack_ is there to answer this: you can see which method called you, which method called that one, and so on.
+Not only that, but you can view the program state at the point of that call. For instance, you can see what values were given as arguments to the method who called the method who called the method you are currently in.
+
+_What happened to cause a crash?_
+Wouldn't it be nice if you could see the program state at the point at which there was a crash on a user's machine?
+Well, you can! The operating system can generate a _crash dump_ that contains the state of the program when it crashes, and you can load that crash dump into a debugger,
+along with the source code of the program and the debugging symbols, to see what the program state was. This is what happens when you click on ""Report the problem to Microsoft"" after your Word document crashed.
+Note that this only works with crashes, not with bugs such as ""the behavior is not what I expect"" since there is no automated way to detect such unexpected behavior.
+
+
+### Debugging in practice
+
+When using a debugger to find the root cause of a bug, you will add a breakpoint, run the program until execution pauses to inspect the state, optionally make some edits to the program given your observations,
+and repeat the cycle until you have found the root cause.
+
+However, sometimes you cannot figure out the problem on your own, and you need help.
+This is perfectly normal, especially if you are debugging code written by someone else.
+In this case, you can ask a colleague for help, or even post on an Internet forum such as [StackOverflow](https://stackoverflow.com).
+Come prepared, so that you can help others help you. What are the symptoms of the bug? Do you have an easy way to reproduce the bug? What have you tried?
+
+Sometimes, you start explaining your problem to a colleague, and during your explanation a light bulb goes off in your head: there's the problem!
+Your colleague then stares at you, happy that you figured it out, but a bit annoyed to be interrupted.
+To avoid this situation, start by _rubber ducking_: explaining your problem to a rubber duck, or to any other inanimate object.
+Talk to the object as if it was a person, explaining what your problem is.
+The reason this works is that when we explain a problem to someone else, we typically explain what is actually happening, rather than what we wish was happening.
+If you don't understand the problem while explaining it to a duck, at least you have rehearsed how you will explain the bug, and you will be able to better explain it to a human.
+
+There is only one way to get better at debugging: practice doing it. Next time you encounter a bug, use a debugger.
+The first few times, you may be slower than you would be without one, but after that your productivity will skyrocket.
+
+---
+#### Exercise
+Run the code in the [binary-tree](exercises/lecture/binary-tree) folder.
+First, run it. It crashes! Use a debugger to add breakpoints and inspect what happens until you figure out why, and fix the bugs.
+Note that the crash is not the only bug.
+
+Answers (click to expand)
++ +`pickling` is a rather odd way to refer to serializing and deserializing data as ""preserving"" it. + +`binhex` sounds like a name for some binary and hexadecimal utilities, but it's actually for a module that handles an old Mac format. + +A linked list and a doubly linked list are not the same thing, yet Java names the latter as if it was the former. + +A vector has a specific meaning in mathematics; C++'s `vector` is really a resizeable array. + +`SortedList` is an acceptable name for a sorted list class. But the class with that name is a sorted map! + +
+
+
+
+
+## What makes code debuggable?
+
+The inventor [Charles Babbage](https://en.wikipedia.org/wiki/Charles_Babbage) once said about a machine of his
+""_On two occasions, I have been asked 'Pray, Mr. Babbage, if you put into the machine wrong figures, will the right answers come out?'_
+_I am not able to rightly apprehend the kind of confusion of ideas that could provoke such a question._""
+
+It should be clear that a wrong input cannot lead to a correct output.
+Unfortunately, often a wrong input leads to a wrong output _silently_: there is no indication that anything wrong happened.
+This makes it hard to find the root cause of a bug.
+If you notice something is wrong, is it because the previous operation did something wrong?
+Or because the operation 200 lines of code earlier produced garbage that then continued unnoticed until it finally caused a problem?
+
+[Margaret Hamilton](https://en.wikipedia.org/wiki/Margaret_Hamilton_\(software_engineer\)),
+who coined the term ""software engineering"" to give software legitimacy based on her experience developing software for early NASA missions,
+[said](https://www.youtube.com/watch?v=ZbVOF0Uk5lU) of her early work ""we learned to spend more time up front [...] so that we wouldn't waste all that time debugging"".
+
+We will see three methods to make code debuggable: defensive programming, logging, and debug-only code.
+
+### Defensive programming
+
+Bugs are attacking you, and you must defend your code and data!
+That's the idea behind _defensive programming_: make sure that problems that happen outside of your code cannot corrupt your state or cause you to return garbage.
+These problems could for instance be software bugs, humans entering invalid inputs, humans deliberately trying to attack the software, or even hardware corruption.
+
+It may seem odd to worry about hardware corruption, but it happens more often than one thinks;
+for instance, a single bit flip can turn `microsoft.com` into `microsfmt.com`, since `o` is usually encoded as `01101101` in binary, which can flip to `01101111`, the encoding for `m`.
+Software that intends to talk to `microsoft.com` could thus end up receiving data from `microsfmt.com` instead, which may be unrelated, specifically set up for attacks, or
+[an experiment to see how much this happens](http://dinaburg.org/bitsquatting.html).
+
+Instead of silently producing garbage, code should fail as early as possible.
+The closest a failure is to its root cause, the easier it is to debug.
+
+The key tool to fail early is _assertions_.
+An assertion is a way to check whether the code actually behaves in the way the engineer who wrote it believes it should.
+
+For instance, if a piece of code finds the `index` of a `value` in an `array`, an engineer could write the following immediately after finding `index`:
+```java
+if (array[index] != val) {
+ throw new AssertionError(...);
+}
+```
+If this check fails, there must be a bug in the code that finds `index`. The ""isolate the bug"" step of debugging is already done by the assertion.
+
+What should be done if the check fails, though? Crash the program?
+This depends on the program. Typically, if there is a way to cut off whatever caused the problem from the rest of the program, that's a better idea.
+For instance, the current _request_ could fail.
+This could be a request made to a server, for instance, or an operation triggered by a user pressing a button.
+The software can then display a message stating an error occurred, enabling the user to either retry or do something else.
+However, some failures are so bad that it is not reasonable to continue.
+For instance, if the code loading the software's configuration fails an assertion, there is no point in continuing without the configuration.
+
+An assertion that must hold when calling a method is a _precondition_ of that method.
+For instance, an `int pickOne(int[] array)` method that returns one of the array's elements likely has as precondition ""the array isn't `null` and has at least `1` element"".
+The beginning of the method might look like this:
+```java
+int pickOne(int[] array) {
+ if (array == null || array.length == 0) {
+ throw new IllegalArgumentException(...);
+ }
+ // ...
+}
+```
+If a piece of code calls `pickOne` with a null or empty array, the method will throw an `IllegalArgumentException`.
+
+Why bother checking this explicitly when the method would fail early anyway if the array was null or empty, since the method will dereference the array and index its contents?
+The type of exception thrown indicates _whose fault it is_.
+If you call `pickOne` and get a `NullPointerException`, it is reasonable to assume that `pickOne` has a bug, because this exception indicates
+the code of `pickOne` believes a given reference is non-null, since it dereferences it, yet in practice the reference is null.
+However, if you call `pickOne` and get an `IllegalArgumentException`, it is reasonable to assume that your code has a bug,
+because this exception indicates you passed an argument whose value is illegal.
+Thus, the type of exception helps you find where the bug is.
+
+An assertion that must hold when a method returns is a _postcondition_ of that method.
+In our example, the postcondition is ""the returned value is some value within the array"", which is exactly what you call `pickOne` to get.
+If `pickOne` returns a value not in the array, code that calls it will yield garbage, because the code expected `pickOne` to satisfy its contract yet this did not happen.
+It isn't reasonable to insert assertions every time one calls a method to check that the returned value is acceptable; instead, it's up to the method to check that it honors its postcondition.
+For instance, the end of `pickOne` might look like this:
+```java
+int result = ...
+if (!contains(array, result)) {
+ throw new AssertionError(...);
+}
+return result;
+```
+This way, if `result` was computed incorrectly, the code will fail before corrupting the rest of the program with an invalid value.
+
+Some assertions are both pre- and postconditions for the methods of an object: _object invariants_.
+An invariant is a condition that always hold from the outside.
+It may be broken during an operation, as long as this is not visible to the outside world because it is restored before the end of the operation.
+For instance, consider the following fields for a stack:
+```java
+class Stack {
+ private int[] values;
+ private int top; // top of the stack within `values`
+}
+```
+An object invariant for this class is `-1 <= top < values.length`, i.e., either `top == -1` which means the stack is empty, or `top` points to the top value of the stack within the array.
+One way to check invariants is to write an `assertInvariants` method that asserts them and call it at the end of the constructor and the beginning and end of each method.
+All methods of the class must preserve the invariant so that they can also rely on it holding when they get called.
+This is one reason encapsulation is so useful: if anyone could modify `values` or `top` without going through the methods of `Stack`,
+there would be no way to enforce this invariant.
+
+Consider the following Java method:
+```java
+void setWords(ListSolution (click to expand)
++ +First, there is no base case to the recursive method that builds a tree, so you should add one to handle the `list.size() == 0` case. + +Second, the bounds for sub-lists are off: they should be `0..mid` and `mid+1..list.size()`. + +There is a correctness bug: the constructor uses `l` twice, when it should set `right` to `r`. This would not have happened if the code used better names! + +We provide a [corrected version](exercises/solutions/lecture/BinaryTree.java). + +
+
+
+
+
+### Logging
+
+_What happened in production?_
+If there was a crash, then you can get a crash dump and open it in a debugger.
+But if it's a more subtle bug where the outcome ""looks wrong"" to a human, how can you know what happened to produce this outcome?
+
+This is where _logging_ comes in: recording what happens during execution so that the log can be read in case something went wrong.
+One simple way to log is print statements:
+```python
+print(""Request: "" + request)
+print(""State: "" + state)
+```
+This works, but is not ideal for multiple reasons.
+First, the developer must choose what to log at the time of writing the program.
+For instance, if logging every function call is considered too much for normal operation, then the log of function calls will never be recorded, even though in some cases it could be useful.
+Second, the developer must choose how to log at the time of writing the program.
+Should the log be printed to the console? Saved to a file? Both? Perhaps particular events should send an email to the developers?
+Third, using the same print function for every log makes it hard to see what's important and what's not so important.
+
+Instead of using a specific print function, logging frameworks provide the abstraction of a log with multiple levels of importance, such as Python's logging module:
+```python
+logging.debug(""Detail"")
+logging.info(""Information"")
+logging.warning(""Warning"")
+logging.error(""Error"")
+logging.critical(""What a Terrible Failure"")
+```
+The number of log levels and their name changes in each logging framwork, but the point is that there are multiple ones and they do not imply anything about where the log goes.
+
+Engineers can write logging calls for everything they believe might be useful, using the appropriate log level, and decide _later_ what to log and where to log.
+For instance, by default, ""debug"" and ""info"" logs might not even be stored, as they are too detailed and not important enough.
+But if there is currently a subtle bug in production, one can enable them to see exactly what is going on, without having to restart the program.
+It may make sense to log errors with an email to the developers, but if there are lots of errors the developers are already aware of,
+they might decide to temporarily log errors to a file instead, again without having to restart the program.
+
+It is important to think about privacy when writing logging code.
+Logging the full contents of every request, for instance, might lead to logging plain text passwords for a ""user creation"" function.
+If this log is kept in a file, and the server is hacked, the attackers will have a nice log of every password ever set.
+
+### Debug-only code
+
+What about defensive programming checks and logs that are too slow to reasonably enable in production?
+For instance, if a graph has as invariant ""no node has more than 2 edges"", but the graph typically has millions of nodes, what to do?
+
+This is where _debug-only_ code comes in.
+Programming languages, their runtimes, and frameworks typically offer ways to run code only in debug mode, such as when running automated tests.
+
+For instance, in Python, one can write an `if __debug__:` block, which will execute only when the code is not optimized.
+
+It's important to double-check what ""debug"" and ""optimized"" mean in any specific context.
+For instance, in Python `__debug__` is `True` by default, unless the interpreter is run with the `-O` switch, for ""optimize"".
+In Java, assertions are debug-only code but they are disabled by default, and can be enabld with the `-ea` switch.
+Scala has multiple levels of debug-only code that are all on by default but can be selectively disabled with the `-Xelide-below` switch.
+
+Even more important, before writing debug-only code, think hard about what is ""reasonable"" to enable in production given the workloads you have.
+Spending half a second checking an invariant is fine in a piece of code that will take seconds to run because it makes many web requests, for instance,
+even though half a second is a lot in CPU time.
+
+Keep in mind what [Tony Hoare](https://en.wikipedia.org/wiki/Tony_Hoare), one of the pioneers of computer science and especially programming languages and verification,
+once said in his [""Hints on Programming Language Design""](https://dl.acm.org/doi/abs/10.5555/63445.C1104368):
+""_It is absurd to make elaborate security checks on debugging runs, when no trust is put in the results,_
+_and then remove them in production runs, when an erroneous result could be expensive or disastrous._
+_What would we think of a sailing enthusiast who wears his life-jacket when training on dry land_
+_but takes it off as soon as he goes to sea?_""
+
+
+## Summary
+
+In this lecture, you learned:
+- How to write readable code: naming, formatting, comments, conventions
+- How to debug code: reproducing bugs, using a debugger
+- How to write debuggable code: defensive programming, logging, debug-only code
+
+You can now check out the [exercises](exercises/)!
+",CS-305: Software engineering
+"# Asynchrony
+
+You're writing an app and want it to download data and process it, so you write some code:
+```java
+data = download();
+process(data);
+```
+This works fine if both of these operations finish in the blink of an eye... but if they take more than that, since these operations are all your code is doing,
+your user interface will be frozen, and soon your users will see the dreaded ""application is not responding"" dialog from the operating system.
+
+Even if your app has no user interface and works in the background, consider the following:
+```java
+firstResult = computeFirst();
+secondResult = computeSecond();
+compare(firstResult, secondResult);
+```
+If `computeFirst` and `computeSecond` are independent, the code as written is likely a waste of resources, since modern machines have multiple
+CPU cores and thus your app could have computed them in parallel before executing the comparison on both results.
+
+Even if you have a single CPU core, there are other resources, such as the disk:
+```java
+for (int i = 0; i < 100; i++) {
+ chunk = readFromDisk();
+ process(chunk);
+}
+```
+As written, this code will spend some of its time reading from the disk, and some of its time processing the data that was read,
+but never both at the same time, which is a waste of resources and time.
+
+These examples illustrate the need for _asynchronous code_.
+For instance, an app can start a download in the background, show a progress bar while the download is ongoing, and process the data once the download has finished.
+Multiple computations can be executed concurrently.
+A disk-heavy program can read data from the disk while it is processing data already read.
+
+
+## Objectives
+
+After this lecture, you should be able to:
+- Understand _asynchrony_ in practice
+- Build async code with _futures_
+- Write _tests_ for async code
+- _Design_ async software components
+
+
+## What are async operations?
+
+Asynchronous code is all about starting an operation without waiting for it to complete. Instead, one schedules what to do after the completion.
+Asynchronous code is _concurrent_, and if resources are available it can also be _parallel_, though this is not required.
+
+There are many low-level primitives you could use to implement asynchrony: threads, processes, fibers, and so on.
+You could then use low-level interactions between those primitives, such as shared memory, locks, mutexes, and so on.
+You could do all of that, but low-level concurrency is _very hard_.
+Even experts who have spent years understanding hardware details regularly make mistakes.
+This gets even worse with multiple kinds of hardware that provide different guarantees, such as whether a variable write is immediately visible to other threads or not.
+
+Instead, we want a high-level goal: do stuff concurrently.
+An asynchronous function is similar to a normal function, except that it has two points of return: synchronously, to let you know the operation has started,
+and asynchronously, to let you know the operation has finished.
+Just like a synchronous function can fail, an asynchronous function can fail, but again at two points: synchronously, to let you know the operation cannot even start,
+perhaps because you gave an invalid argument, and asynchronously, to let you know the operation has failed, perhaps because there was no Internet connection even after retrying in the background.
+
+We would like our asynchronous operations to satisfy three goals: they should be composable, they should be completion-based, and they should minimize shared state.
+Let's see each of these three.
+
+### Composition
+
+When baking a cake, the recipe might tell you ""when the melted butter is cold _and_ the yeast has proofed, _then_ mix them to form the dough"".
+This is a kind of composition: the recipe isn't telling you to stand in front of the melted butter and watch it cool, rather it lets you know what operations must finish for the next step and what that next step is.
+You are free to implement the two operations however you like; you could stand in front of the butter, or you could go do something else and come back later.
+
+Composition is recursive: once you have a dough, the next step might be ""when the dough has risen _and_ the filling is cold, _then_ fill the dough"".
+Again, this is a composition of asynchronous operations into one big operation representing making a filled dough.
+
+The two previous examples were _and_, but _or_ is also a kind of composition. The recipe might tell you ""bake for 30 minutes, _or_ until golden brown"".
+If the cake looks golden brown after 25 minutes, you take it out of the oven, and forget about the 30 minutes.
+
+One important property of composition is that errors must implicitly compose, too.
+If the ripe strawberries you wanted to use for the filling splash on the floor, your overall ""bake a cake"" operation has failed.
+The recipe doesn't explicitly tell you that, because it's a baking convention that if any step fails, you should stop and declare the whole operation a failure, unless you can re-do the failed operation from scratch.
+Maybe you have other strawberries you can use instead.
+
+### Completion
+
+If you have a cake you'd like to bake, you could ask a baker ""please let me know when you've finished baking the cake"", which is _completion-based_.
+
+Alternatively, you could ask them ""please let me know when the oven is free"" and then bake it yourself, which is a bit lower level and gives you more control.
+This is _readiness-based_, and some older APIs, such as those found on Unix, were designed that way.
+
+The problem with readiness-based operations is that they lead to inefficiencies due to concurrent requests.
+The baker just told you the oven was ready, but unbeknownst to you, another person has put their cake in the oven before you've had time to get there.
+Now your ""put the cake in the oven"" operation will fail, and you have to ask the baker to let you know when the oven is free again, at which point the same problem could occur.
+
+### Minimizing shared state
+
+Multiple asynchronous operations might need to read and write to the same shared state.
+For instance, the task of counting all elements in a large collection that satisfy some property could be parallelized by dividing the collection into chunks and processing multiple chunks in parallel.
+Each sub-task could then increment a global counter after every matching element it sees.
+
+However, shared state introduces an exponential explosion in the number of paths through a piece of software.
+There is one path in which the code of sub-task 1 accesses the shared state first, and one in which sub-task 2 accesses it first, and so on for each sub-task and for each shared state access.
+Even with a simple counter, one already needs to worry about atomic updates.
+With more complex shared state, one needs to worry about potential bugs that only happen with specific ""interleavings"" of sub-task executions.
+For instance, there may be a crash only if sub-task 3 accessed shared state first, followed by 2, followed by 3 again, followed by 1.
+This may only happen to a small fraction of users.
+Then one day, a developer speeds up the code of sub-task 3, and now the bug happens more frequently because the problematic interleaving is more common.
+The next day, a user gets an operating system update which slightly changes the scheduling policy of threads in the kernel. Now the bug happens all the time for this user,
+because the operating system happens to choose an order of execution that exposes the bug on that user's machine.
+
+Asynchronous operations must minimize shared state, for instance by computing a local result, then merging all local results into a single global result at the end.
+
+One extreme form of minimizing state is _message passing_: operations send each other messages rather than directly accessing the same state.
+For instance, operations handling parts of a large collection could do their work and then send their local result as a message to another ""monitor"" operation which is responsible for merging these results.
+Message passing is the standard way to communicate for operations across machines already, so it can make sense to do it even on a single machine.
+One interesting use of this is the [Multikernel](https://www.sigops.org/s/conferences/sosp/2009/papers/baumann-sosp09.pdf), an operating system that can run on multiple local CPUs each of a different architecture,
+because it uses only message passing and never shared memory, thus what each local thread runs on is irrelevant.
+
+
+## How can we write maintainable async code?
+
+A simple and naïve way to write asynchronous code is with _callbacks_.
+Instead of returning a value, functions take an additional callback argument that is called with the value once it's ready:
+```java
+void send(String text, ConsumerSolution (click to expand)
++ +First, the constructor needs to throw if `maxSize < 0`, since that is invalid. + +Second, the stack should have the invariant `-1 <= top < values.length`, as discussed above. + +After adding this invariant, note that `top--` in `pop` can break the invariant since it is used unconditionally. The same goes for `top++` in `push`. +These need to be changed to only modify `top` if necessary. + +To enable the users of `IntStack` to safely call `push`, one can expose an `isFull()` method, and use it as a precondition of `push`. + +We provide a [corrected version](exercises/solutions/lecture/Stack.java). + +
+
+
+---
+
+### Sync over async
+
+Doing the exercise above, you've noticed `App.java` uses `join()` to block until a future finishes and either return the result or throw the error represented by the future.
+There are other such ""sync over async"" operations, such as `isDone()` and `isCompletedExceptionallly()` to check a future's status.
+
+""Sync over async"" operations are useful specifically to use asynchronous operations in a context that must be synchronous,
+typically because you are working with a framework that expects a synchronous operation.
+Java's `main()` method must be synchronous, for instance.
+JUnit also expects `@Test`s to be synchronous.
+This is not true of all frameworks, e.g., C# can have asynchronous main methods, and most C# testing frameworks support running asynchronous test methods.
+
+You might also need to use methods such as `isDone()` if you are implementing your own low-level infrastructure code for asynchronous functions, though that is a rare scenario.
+
+In general, everyday async functions must _not_ use `join()` or any other method that attempts to synchronously wait for or interact with an asynchronous operation.
+If you call any of these methods on a future outside of a top-level method such as `main` or a unit test, you are most likely doing something wrong.
+For instance, if in a button click handler you call `join()` on a `CompletableFuture` representing the download of a picture, you will freeze the entire app until the picture is downloaded.
+Instead, the button click handler should compose that future with the operation of processing the picture, and the app will continue working while the download and processing happen in the background.
+
+### Sync errors
+
+Another form of synchrony in asynchronous operations is synchronous errors, i.e., signalling that an asynchronous operation could not even be created.
+Unlike asynchronous errors contained in Futures, which in Java are handled with methods such as `exceptionally(...)`, synchronous errors are handled with the good old `try { ... } catch { ... }` statement.
+Thus, if you call a method that could fail synchronously or asynchronously and you want to handle both cases, you must write the error handling code twice.
+
+Only use sync errors for bugs, i.e., errors that are not recoverable and indicate something has gone wrong such as an `IllegalArgumentException`:
+```java
+CompletableFutureSuggested solution (click to expand)
++ +- Printing today's weather is done by composing `Weather.today` with `System.out.println` using `thenAccept` +- Uploading today's weather is done by composing `Weather.today` with `Server.upload` using `thenCompose` +- Printing either weather is done using `acceptEither` on two individual futures, both of which use `thenApply` to prefix their results, with `System.out.println` as the composition operation +- Finally, `Weather.all` should be composed with `orTimeout` and `exceptionallyCompose` to use `Weather.today` as a backup + +We provide a [solution example](exercises/solutions/lecture/src/main/java/Basics.java). + +
+
+
+---
+
+### In other languages
+
+We have seen futures in Java as `CompletableFuture`, but other languages have roughly the same concept with different names such as `Promise` in JavaScript,
+`TaskSuggested solution (click to expand)
+
+
+- `Server.uploadBatch` should be modified to support cancellation as indicated above, and then used in a way that sets the cancel flag if the operation times out using `orTimeout`
+- Converting `OldServer.download` can be done by creating a `CompletableFuture
+
+
+---
+
+## How does asynchrony interact with software design?
+
+Which operations should be sync and which should be async, and why?
+This is a question you will encounter over and over again when engineering software.
+
+One naïve option is to make everything asynchronous. Even `1 + 1` could be `addAsync(1, 1)`! This is clearly going too far.
+
+It's important to remember that _asynchrony is viral_: if a method is async, then the methods that call it must also be async, though it can itself call sync methods.
+A sync method that calls an async method is poor design outside of the very edges of your system, typically tests and the main method,
+because it will need to block until the async method is done, which can introduce all kinds of issues such as UI freezes or deadlocks.
+
+This also applies to inheritance: if a method might be implemented in an asynchronous way, but also has other synchronous implementations, it must be async.
+For instance, while fetching the picture for an album in a music player may be done from a local cache in a synchronous way, it will also sometimes be done by downloading the image from the Internet.
+Thus, you should make operations async if they are expected to be implemented in an asynchronous way, typically I/O operations.
+
+One policy example is the one in the [Windows Runtime APIs](https://learn.microsoft.com/en-us/windows/uwp/cpp-and-winrt-apis/concurrency#asynchronous-operations-and-windows-runtime-async-functions),
+which Microsoft introduced with Windows 8.
+Any operation that has the potential to take more than 50 milliseconds to complete returns a future instead of a synchronous result.
+50ms may not be the optimal threshold for everything, but it is a reasonable and clear position to take that enables engineers to decide whether any given operation should be asynchronous.
+
+Remember the ""YAGNI"" principle: ""_You Aren't Gonna Need It"".
+Don't make operations async because they might perhaps one day possibly maybe need to be async.
+Only do so if there is a clear reason to. Think of how painful, or painless, it would be to change from sync to async if you need it later.
+
+One important principle is to be consistent.
+Perhaps you are using an OS that gives you asynchronous primitives for reading and writing to files, but only a synchronous primitive to delete it.
+You could expose an interface like this:
+```java
+class File {
+ CompletableFutureSuggested solution (click to expand)
+
+
+- As we did above, call `orTimeout(...)` then `join()` on `Weather.today()`, then assert that its result is `""Sunny""`
+- Create a `CompletableFuture
+
+
+
+## What does modularity require in practice?
+
+It is all too easy to write software systems in which each ""module"" is a mishmash of concepts, modules depend on each other without any clear pattern.
+Maintaining such a system requires reading and understanding most of the system's code, which doesn't scale to large systems.
+We have seen the theoretical benefits and pitfalls of modularity, now let's see how to design modular systems in practice.
+
+We will talk about the _regularity_ of interfaces, _grouping_ and _layering_ modules, and organizing modules by _abstraction level_.
+
+### Regularity
+
+Consider fractals such as this one:
+
+Proposed solution (click to expand)
++ +A campus companion app could view students as having a name and preferences such as whether to display vegetarian menus first or in what order to display the user's courses. + +The campus companion does not care about whether the student has paid their fee for the current semester, which is something a course management system might care about, +along with what major the student is in. + +Neither the campus companion nor the course management should know what the user's password is, or even the concept of passwords since the user might log in using biometric data or two-factor authentication. +Those concepts are what the authentication system cares about for students. + +
+
+
+
+---
+
+At this point, you may be wondering: how far should you go with modularization? Should your programs consist of thousands of tiny modules stacked hundreds of layers high?
+Probably not, as this would cause maintainability issues just like having a single big module for everything does. But where to stop?
+
+There is no single objective metric to tell you how big or small a module should be, but here are some heuristics.
+You can estimate _size_ using the number of logical paths in a module. How many different things can the module do?
+If you get above a dozen or so, the module is probably too big.
+You can estimate _complexity_ using the number of inputs for a module. How many things does the module need to do its job?
+If it's more than four or five, the module is probably too big.
+
+Remember the acronym _YAGNI_, for ""You Aren't Gonna Need It"".
+You could split that module into three even smaller parts that hypothetically could be individually reused, but will you need this? No? You Aren't Gonna Need It, so don't do it.
+You could provide ten different parameters for one module to configure every detail of what it does, but will you need this? No? You Aren't Gonna Need It, so don't do it.
+
+One way to discuss designs with colleagues is through the use of diagrams such as [UML class diagrams](https://en.wikipedia.org/wiki/Class_diagram),
+in which you draw modules with their data and operations and link them to indicate composition and inheritance relationships.
+Keep in mind that the goal is to discuss system design, not to adhere to specific conventions.
+As long as everyone agrees on what each diagram element means, whether or not you adhere to a specific convention such as UML is irrelevant.
+
+Beware of the phenomenon known as ""[cargo cult programming](https://en.wikipedia.org/wiki/Cargo_cult_programming)"".
+The idea of a ""cargo cult"" originated in remote islands used by American soldiers as bases during wars.
+These islands were home to native populations who had no idea what planes were, but who realized that when Americans did specific gestures involving military equipment,
+cargo planes full of supplies landed on the islands. They naturally hypothesized that if they, the natives, could replicate these same gestures, more planes might land!
+Of course, from our point of view we know this was useless because they got the correlation backwards: Americans were doing landing gestures because they knew planes were coming, not the other way around.
+But the natives did not know that, and tried to get cargo planes to land.
+Some of these cults lasted for longer than they should have, and their modern-day equivalent in programming is engineers who design their system
+""because some large company, like Google or Microsoft, does it that way"" without the knowledge nor the understanding of why the large company does it that way.
+Typically, big system in big companies have constraints that do not apply to the vast majority of systems, such as dealing with thousands of requests per second or having to provide extreme availability guarantees.
+
+
+## How can one mitigate the impact of failures?
+
+What should happen when one part of a system has a problem?
+
+[Margaret Hamilton](https://en.wikipedia.org/wiki/Margaret_Hamilton_(software_engineer)), who along with her team wrote the software that put spaceships in orbit and people on the Moon,
+recalled [in a lecture](https://www.youtube.com/watch?v=ZbVOF0Uk5lU) how she tried persuading managers to add a safety feature to a spaceship.
+She had brought her young daughter to work one day, and her daughter tried the spaceship simulator. Surprisingly, the daughter managed to crash the software running in the simulator.
+It turned out that the software was not resilient to starting one operation while the spaceship was supposed to be in a completely different phase of flight.
+Hamilton tried to persuade her managers that the software should be made resilient to such errors, but as she recalls it:
+""_[the managers] said 'this won't ever happen, astronauts are well-trained, they don't make mistakes... the very next mission, Apollo 8, this very thing happened [...] it took hours to get [data] back_"".
+
+The lack of a check for this condition was an _error_, i.e., the team who programmed the software chose not to consider a problem that might happen in practice.
+Other kinds of errors involve forgetting to handle a failure case, or writing code that does not do what the programmer think it does.
+
+Errors cause _defects_ in the system, which can be triggered by external inputs, such as an astronaut pressing the wrong button.
+If defects are not handled, they cause _failures_, which we want to avoid.
+
+Errors are inevitable in any large system, because systems involve humans and humans are fallible. ""Just don't make errors"" is not a realistic solution.
+Even thinking about all possible failure cases is hard; consider the ""[Cat causes login screen to hang](https://bugs.launchpad.net/ubuntu/+source/unity-greeter/+bug/1538615)"" in Ubuntu.
+Who would have thought that thousands of characters in a username input field was a realistic possibility from a non-malicious user?
+
+Preventing failures thus requires preventing defects from propagating through the system, i.e., _mitigating_ the impact of defects.
+We will see four ways to do it, all based on modules: isolating, repairing, retrying, and replacing.
+
+How much effort you should put into tolerating defects depends on what is at stake.
+A small script you wrote yourself to fetch cartoons should be tolerant to temporary network errors, but does not need advanced recovery techniques.
+On the other hand, the [barrier over the Thames river](https://www.youtube.com/watch?v=eY-XHAoVEeU) that prevents mass floods needs to be resilient against lots of possible defects.
+
+### Isolating
+
+Instead of crashing an entire piece of software, it is desirable to _isolate_ the defect and crash only one module, as small and close to the source of the defect as possible.
+For instance, modern Web browsers isolate each tab into its own module, and if the website inside the tab causes a problem, only that tab needs to crash, not the entire browser.
+Similarly, operating systems isolate each program such that only the program crashes if it has a defect, not the entire operating system.
+
+However, only isolate if the rest of the program can reasonably function without the failed module.
+For instance, if the module responsible for drawing the overall browser interface crashes, the rest of the browser cannot function.
+On the other hand, crashing only a browser tab is acceptable, as the user can still use other tabs.
+
+### Repairing
+
+Sometimes a module can go into unexpected states due to defects, at which point it can be _repaired_ by switching to a well-known state.
+This does not mean moving from the unexpected state in some direction, since the module does not even know where it is, but replacing the entirety of the module's state with a specific ""backup"" state that is known to work.
+An interesting example of this is [the ""top secret"" room](https://zelda-archive.fandom.com/wiki/Top_Secret_Room) in the video game _The Legend of Zelda: A Link to the Past_.
+If the player manages to get the game into an unknown state, for instance by switching between map areas too quickly for the game to catch up,
+the game recognizes that it is confused and drops the player into a special room, and pretends that this is intentional and the player has found a secret area.
+
+One coarse form of repair is to ""turn it off and on again"", such as restarting a program, or rebooting the operating system.
+The state immediately after starting is known to work, but this cannot be hidden from users and is more of a way to work around a failure.
+
+However, only repair if the entirety of a module's state can be repaired to a state known to work.
+Repairing only part of a module risks creating a Frankenstein abomination that only makes the problem worse.
+
+### Retrying
+
+Not all failures are forever. Some failures come from external causes that can fix themselves without your intervention, and thus _retrying_ is often a good idea.
+For instance, if a user's Internet connection fails, any Web request your app made will fail. But it's likely that the connection will be restored quickly, for instance
+because the user was temporarily in a place with low cellular connectivity such as a tunnel.
+Thus, retrying some number of times before giving up avoids showing unnecessary failures to the user.
+How many times to retry, and how much to wait before retries, is up to you, and depends on the system and its context.
+
+However, only retry if a request is _idempotent_, meaning that doing it more than once has the same effect as doing it once.
+For instance, withdrawing cash from a bank account is not an idempotent request. If you retry it because you didn't get a response, but the request had actually reached the server, the cash will be withdrawn twice.
+
+You should also only retry when encountering problems that are _recoverable_, i.e., for which retrying has a chance to succeed because they come from circumstances beyond your control that could fix themselves.
+For instance, ""no internet"" is recoverable, and so is ""printer starting and not ready yet"". This is what Java tried to model as ""checked"" exceptions: if the exception is recoverable,
+the language should force the developer to deal with it.
+On the other hand, problems such as ""the desired username is already taken"" or ""the code has a bug which divided by zero"" are not recoverable, because retrying will hit the same issue again and again.
+
+### Replacing
+
+Sometimes there is more than one way to perform a task, and some of these ways can serve as backups, _replacing_ the main module if there is a problem.
+For instance, if a fingerprint reader cannot recognize a user's finger because the finger is too wet, an authentication system could ask for a password instead.
+
+However, only replace if you have an alternative that is as robust and tested as the original one.
+The ""backup"" module should not be old code that hasn't been run in years, but should be treated with the same care and quality bar as the main module.
+
+
+## How can one reuse concepts across software systems?
+
+When designing a system, the context is often the same as in previous systems, and so are the user requirements.
+For instance, ""cross over a body of water"" is a common requirement and context that leads to the natural solution ""build a bridge"".
+If every engineer designed the concept of a bridge from scratch every time someone needed to cross a body of water,
+each bridge would not be very good, as it would not benefit from the knowledge accumulated by building previous bridges.
+Instead, engineers have blueprints for various kinds of bridges, select them based on the specifics of the problem, and propose improvements when they think of any.
+
+In software engineering, these kinds of blueprints are named _design patterns_, and are so common that one sometimes forgets they even exist.
+For instance, consider the following Java loop:
+```java
+for (int item : items) {
+ // ...
+}
+```
+This `for` construct looks perfectly normal and standard Java, but it did not always exist.
+It was introduced in Java 1.5, alongside the `IterableSuggested solution (click to expand)
++ +Create one function for obtaining user input, one for parsing it into tokens, one for evaluating these tokens, and one for printing the output or lack thereof. +The evaluation function can internally use another function to execute each individual operator, so that all operators are in one place and independent of input parsing. +See the [solution file](exercises/solutions/lecture/Calc.java) for an example, which has the following structure: + +```mermaid +graph TD + A[main] + B[getInputl] + C[parseInput] + D[compute] + E[execute] + F[display] + A --> B + A --> C + A --> D + A --> F + D --> E +``` + +
+
+
+
+---
+
+MVP does have disadvantages.
+First, the view now holds state, as it is updated incrementally. This pushes more code into the view, despite one of our original goals being to have as little code in the view as possible.
+Second, the interface between the view and the presenter often becomes tied to specific actions that the view can do given the context, such as a console app, and it's hard to make the view generic over many form factors.
+
+### Model-View-ViewModel (MVVM)
+
+Let's take a step back before describing the next pattern.
+What is a user interface anyway?
+- Data to display
+- Commands to execute
+
+...and that's it! At a high-level, at least.
+
+The key idea behind MVVM is that the view should observe data changes using the Observer pattern,
+and thus the intermediary module, the viewmodel, only needs to be a platform-independent user interface that exposes data, commands,
+and an Observer pattern implementation to let views observe changes.
+
+The result is a cleanly layered system, in which the view has little code and is layered on top of the viewmodel, which holds state and itself uses the model to update its state when commands are executed:
+
+Suggested solution (click to expand)
++ +The model should provide a method to get the forecast, and the view should provide a method to show text and one to run the application. +Then, move the existing code into implementations of the model and the view, and write a presenter that binds them together. +See the [solution file](exercises/solutions/lecture/Weather.java) for an example. + +
+
+
+
+---
+
+Beware: just because you _can_ use all kinds of patterns does not mean you _should_.
+Remember to avoid cargo cults! If ""You Aren't Gonna Need It"", don't do it.
+Otherwise you might end up with an ""implementation of AspectInstanceFactory that locates the aspect from the BeanFactory using a configured bean name"",
+just in case somebody _could_ want this flexibility.
+[Really](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/aop/config/SimpleBeanFactoryAwareAspectInstanceFactory.html)!
+
+## Summary
+
+In this lecture, you learned:
+- Abstraction and modularity, and how to use them in practice: regularity, grouping, layering, abstraction levels, and abstraction leaks
+- Tolerating defects: isolating, retrying, repairing, and replacing
+- Design patterns, and specifically common ones to decouple user interfaces, business logic, and reusable strategies: MVC, MVP, MVVM, and Middleware
+
+You can now check out the [exercises](exercises/)!
+",CS-305: Software engineering
+"# Design Patterns
+
+This document contains a curated list of common design patterns, including context and examples.
+
+_These examples are there to concisely illustrate patterns._
+_Real code would also include visibility annotations (`public`, `private`, etc.), make fields `final` if possible,_
+_provide documentation, and other improvements that would detract from the point being made by each example._
+
+
+## Adapter
+
+An _adapter_ converts an object of type `X` when it must be used with an interface that accepts only objects of type `X'`, similar but not the same as `X`.
+For instance, an app may use two libraries that both represent color with four channels, one B/G/R/A and one A/R/G/B.
+It is not possible to directly use an object from one library with the other library, and that's where you can use an _adapter_:
+an object that wraps another object and provides a different interface.
+
+A real-world example is an electrical adapter, for instance to use a Swiss device in the United States: both plugs fundamentally do the same job,
+but one needs a passive adapter to convert from one plug type to the other.
+
+Example:
+```java
+interface BgraColor {
+ // 0 = B, 1 = G, 2 = R, 3 = A
+ float getChannel(int index);
+}
+
+interface ArgbColor {
+ float getA();
+ float getR();
+ float getG();
+ float getB();
+}
+
+class BgraToArgbAdapter implements ArgbColor {
+ BgraColor wrapped;
+
+ BgraToArgbAdapter(BgraColor wrapped) {
+ this.wrapped = wrapped;
+ }
+
+ @Override public float getA() { return wrapped.getChannel(3); }
+ @Override public float getR() { return wrapped.getChannel(2); }
+ @Override public float getG() { return wrapped.getChannel(1); }
+ @Override public float getB() { return wrapped.getChannel(0); }
+}
+```
+
+
+## Builder
+
+A _builder_ works around the limitations of constructors when an object must be immutable yet creating it all at once is not desirable.
+For instance, a `Rectangle` with arguments `width, height, borderThickness, borderColor, isBorderDotted, backgroundColor` is complex,
+and a constructor with all of these arguments would make code creating a `Rectangle` hard to read.
+Furthermore, some arguments logically form groups: it is not useful to specify both `borderColor` and `isBorderDotted` if one does not want a border.
+Creating many rectangles that share all but a few properties is also verbose if one must re-specify all of the common properties every time.
+Instead, one can create a `RectangleBuilder` object that defines property groups, uses default values for unspecified properties,
+and has a `build()` method to create a `Rectangle`.
+Each method defining properties returns `this` so that the builder is easier to use.
+
+A special case of builders is when creating an object incrementally is otherwise too expensive, as in immutable strings in many languages.
+If one wants to create a string by appending many chunks, using the `+` operator will copy the string data over and over again, creating many intermediate strings.
+For instance, appending `[""a"", ""b"", ""c"", ""d""]` without a builder will create the intermediate strings `""ab""` and `""abc""` which will not be used later.
+In contrast, a `StringBuilder` can internally maintain a list of appended strings, and copy their data only once when building the final string.
+
+Example:
+```java
+class Rectangle {
+ public Rectangle(int width, int height, int borderThickness, Color borderColor, boolean isBorderDotted, Color backgroundColor, ...) {
+ ...
+ }
+}
+
+class RectangleBuilder {
+ // width, height are required
+ RectangleBuilder(int width, int height) { ... }
+ // optional, no border by default
+ RectangleBuilder withBorder(int thickness, Color color, boolean isDotted) { ... ; return this; }
+ // optional, no background by default
+ RectangleBuilder withBackgroundColor(Color color) { ... ; return this; }
+ // to create the rectangle
+ Rectangle build() { ... }
+}
+
+// Usage example:
+new RectangleBuilder(100, 200)
+ .withBorder(10, Colors.BLACK, true)
+ .build();
+```
+
+
+## Composite
+
+A _composite_ handles a group of objects of the same kind as a single object, through an object that exposes the same interface as each individual object.
+For instance, a building with many apartments can expose an interface similar to that of a single apartment, with operations such as ""list residents"" that compose the results
+of calling the operation on each apartment in the building.
+
+Example:
+```java
+interface FileSystemItem {
+ String getName();
+ boolean containsText(String text);
+ ...
+}
+
+class File implements FileSystemItem {
+ // implementation for a file
+}
+
+class Folder implements FileSystemItem {
+ Folder(String name, ListSuggested solution (click to expand)
++ +Your middleware needs to use the wrapped model in a loop, possibly with a limit on retries. +See the [solution file](exercises/solutions/lecture/RetryingWeather.java) for an example. + +
+
+
+
+---
+
+**Should you test many things in one method, or have many small test methods?**
+Think of what the tests output will look like if you combine many tests in one method.
+If the test method fails, you will only get one exception message about the first failure in the method, and will not know whether the rest of the test method would pass.
+Having big test methods also means the fraction of passing tests is less representative of the overall code correctness.
+In the extreme, if you wrote all assertions in a single method, a single bug in your code would lead to 0% of passing tests.
+Thus, you should prefer small test methods that each test one ""logical"" concept, which may need one or multiple assertions.
+This does not mean one should copy-paste large blocks of code between tests; instead, share code using features such as JUnit's `@BeforeAll`, `@AfterAll`, `@BeforeEach`, and `@AfterEach` annotations.
+
+**How can you test private methods?** You **don't**.
+Otherwise the tests must be rewritten every time the implementation changes.
+Think back to the SQLite example: the code would be impossible to change if any change in implementation details required modifying even a fraction of the 90 million lines of tests.
+
+**What standards should you have for test code?**
+The same as for the rest of the code.
+Test code should be in the same version control repository as other code, and should be reviewed just like other code when making changes.
+This also means tests should have proper names, not `test1` or `testFeatureWorks` but specific names that give information in an overview of tests such as `nameCanIncludeThaiCharacters`.
+Avoid names that use vague descriptions such as ""correctly"", ""works"", or ""valid"".
+
+
+## What metric can one use to evaluate tests?
+
+What makes a good test?
+When reviewing a code change, how does one know whether the existing tests are enough, or whether there should be more or fewer tests?
+When reviewing a test, how does one know if it is useful?
+
+There are many ways to evaluate tests; we will focus here on the most common one, _coverage_.
+Test coverage is defined as the fraction of code executed by tests compared to the total amount of code.
+Without tests, it is 0%. With tests that execute each part of the code at least once, it is 100%.
+But what is a ""part of the code""? What should be the exact metric for coverage?
+
+One naïve way to do it is _line_ coverage. Consider this example:
+
+```java
+int getFee(Package pkg) {
+ if (pkg == null) throw ...;
+ int fee = 10;
+ if (pkg.isHeavy()) fee += 10;
+ if (pkg.isInternational()) fee *= 2;
+ return fee;
+}
+```
+
+A single test with a non-null package that is both heavy and international will cover both lines.
+This may sound great since the coverage is 100% and easy to obtain, but it is not.
+If the `throw` was on a different line instead of being on the same line as the `if`, line coverage would no longer be 100%.
+It is not a good idea to define a metric for coverage that depends on code formatting.
+
+Instead, the simplest metric for test coverage is _statement_ coverage.
+In our example, the `throw` statement is not covered but all others are, and this does not change based on code formatting.
+Still, reaching almost 100% statement coverage based on a single test for the code above seems wrong.
+There are three `if` statements, indicating the code performs different actions based on a condition, yet we ignored the implicit `else` blocks in those ifs.
+
+A more advanced form of coverage is _branch_ coverage: the fraction of branch choices that are covered.
+For each branch, such as an `if` statement, 100% branch coverage requires covering both choices.
+In the code above, branch coverage for our single example test is 50%: we have covered exactly half of the choices.
+
+Reaching 100% can be done with two additional tests: one null package, and one package that is neither heavy nor international.
+
+But let us take a step back for a moment and think about what our example code can do:
+
+Example solution (click to expand)
++ +You could test `fibonacci` using the `is` matcher we discussed earlier for numbers such as 1 and 10, and test that it throws an exception with numbers below `0` using `assertThrows`. + +To test `split`, you could use Hamcrest's `contains` matcher, and for the shuffling function, you could use `arrayContainingInAnyOrder`. + +We provide some [examples](exercises/solutions/lecture/FunctionsTests.java). + +
+
+
+
+----
+
+Testing after deployment is commonly known as **regression testing**. The goal is to ensure old bugs do not come back.
+
+When confronted with a bug, the idea is to first write a failing test that reproduces the bug, then fix the bug, then run the test again to show that the bug is fixed.
+It is crucial to run the test before fixing the bug to ensure it actually fails.
+Otherwise, the test might not actually reproduce the bug, and will ""pass"" after the bug fix only because it was already passing before, providing no useful information.
+
+Recall the SQLite example: all of these 90 million lines of code show that a very long list of possible bugs will not appear again in any future release.
+This does not mean there are no bugs left, but that many if not all common bugs have been removed, and that the rest are most likely unusual edge cases that nobody has encountered yet.
+
+
+## How can one test entire modules?
+
+Up until now we have seen tests for pure functions, which have no dependencies on other code.
+Testing them is useful to gain confidence in their correctness, but not all code is structured as pure functions.
+
+Consider the following function:
+
+```java
+/** Downloads the book with the given ID
+ * and prints it to the console. */
+void printBook(String bookId);
+```
+
+How can we test this? First off, the function returns `void`, i.e., nothing, so what can we even test?
+The documentation also mentions downloading data, but from where does this function do that?
+
+We could test this function by passing a book ID we know to be valid and checking the output.
+However, that book could one day be removed, or have its contents update, invalidating our test.
+
+Furthermore, tests that depend on the environment such as the book repository this function uses cannot easily test edge cases.
+How should we test what happens if there is a malformed book content? Or if the Internet connection drops after downloading the table of contents but before downloading the first chapter?
+
+One could design _end-to-end tests_ for this function: run the function in a custom environment, such as a virtual machine whose network requests are intercepted,
+and parse its output from the console, or perhaps redirect it to a file.
+While end-to-end testing is useful, it requires considerable time and effort, and is infrastructure that must be maintained.
+
+Instead, let's address the root cause of the problem: the input and output to `printBook` are _implicit_, when they should be _explicit_.
+
+Let's make the input explicit first, by designing an interface for HTTP requests:
+
+```java
+interface HttpClient {
+ String get(String url);
+}
+```
+
+We can then give an `HttpClient` as a parameter to `printBook`, which will use it instead of doing HTTP requests itself.
+This makes the input explicit, and also makes the `printBook` code more focused on the task it's supposed to do rather than on the details of HTTP requests.
+
+Our `printBook` function with an explicit input thus looks like this:
+
+```java
+void printBook(
+ String bookId,
+ HttpClient client
+);
+```
+
+This process of making dependencies explicit and passing them as inputs is called **dependency injection**.
+
+We can then test it with whatever HTTP responses we want, including exceptions, by creating a fake HTTP client for tests:
+
+```java
+var fakeClient = new HttpClient() {
+ @Override
+ public String get(String url) { ... }
+}
+```
+
+Meanwhile, in production code we will implement HTTP requests in a `RealHttpClient` class so that we can call `printBook(id, new RealHttpClient(...))`.
+
+We could make the output explicit in the same way, by creating a `ConsolePrinter` interface that we pass as an argument to `printBook`.
+However, we can change the method to return the text instead, which is often simpler:
+
+```java
+String getBook(
+ String bookId,
+ HttpClient client
+);
+```
+
+We can now test the result of `getBook`, and in production code feed it to `System.out.println`.
+
+Adapting code by injecting dependencies and making outputs explicit enables us to test more code with ""simple"" tests rather than complex end-to-end tests.
+While end-to-end tests would still be useful to ensure we pass the right dependencies and use the outputs in the right way, manual testing for end-to-end scenarios already provides
+a reasonable amount of confidence. For instance, if the code is not printing to the console at all, a human will definitely notice it.
+
+This kind of code changes can be done recursively until only ""glue code"" between modules and low-level primitives remain untestable.
+For instance, an ""UDP client"" class can take an ""IP client"" interface as a parameter, so that the UDP functionality is testable.
+The implementation of the ""IP client"" interface can itself take a ""Data client"" interface as a parameter, so that the IP functionality is testable.
+The implementations of the ""Data client"" interface, such as Ethernet or Wi-Fi, will likely need end-to-end testing since they do not themselves rely on other local software.
+
+---
+#### Exercise
+It's your turn now! In [the in-lecture exercise project](exercises/lecture) you will find `JokeFetcher.java`, which is not easy to test in its current state.
+Change it to make it testable, write tests for it, and change `App.java` to match the `JokeFetcher` changes and preserve the original program's functionality.
+Start by writing an interface for an HTTP client, implement it by moving existing code around, and use it in `JokeFetcher`. Then add tests.
+
+Example tests (click to expand)
++ +You could have five tests: the counter initializes to zero, the ""increment"" method increments the counter, +the ""reset"" method sets the counter to zero, the ""increment"" method does not increment beyond the maximum, +and the maximum cannot be below zero. + +We provide [sample tests](exercises/solutions/lecture/PeopleCounterTests.java) and [a reference implementation](exercises/solutions/lecture/PeopleCounter.java). + +
+
+
+
+----
+
+If you need to write lots of different fake dependencies, you may find _mocking_ frameworks such as [Mockito](https://site.mockito.org/) for Java useful.
+These frameworks enable you to write a fake `HttpClient`, for instance, like this:
+
+```java
+var client = mock(HttpClient.class);
+when(client.get(anyString())).thenReturn(""Hello"");
+// there are also methods to throw an exception, check that specific calls were made, etc.
+```
+
+There are other kinds of tests we have not talked about in this lecture, such as performance testing, accessibility testing, usability testing, and so on.
+We will see some of them in future lectures.
+
+
+## Summary
+
+In this lecture, you learned:
+- Automated testing, its basics, some good practices, and how to adapt code to make it testable
+- Code coverage as a way to evaluate tests, including statement coverage, branch coverage, and path coverage
+- When tests are useful, including testing after development, TDD, and regression tests
+
+You can now check out the [exercises](exercises/)!
+",CS-305: Software engineering
+"# Mobile Platforms
+
+This lecture's purpose is to give you a high-level picture of what the universe of mobile applications and devices is like. You will read about:
+
+* Differences between desktops and mobile devices w.r.t. applications, security, energy, and other related aspects
+* Challenges and opportunities created by mobile platforms
+* Brief specifics of the Android stack and how applications are structured
+* A few ideas for offering users a good experience on their mobile
+* The ecosystem that mobile apps plug into
+
+## From desktops to mobiles
+
+Roughly every decade, a new, lower priced computer class forms, based on a new programming platform, network, and interface. This results in new types of usage, and often the establishment of a new industry. This is known as [Bell's Law](https://en.wikipedia.org/wiki/Bell%27s_law_of_computer_classes).
+
+With every new computer class, the number of computers per person increases drastically. Today we have clouds of vast data centers, and perhaps an individual computer, like our laptop, that we use to be productive. On top of that come several computer devices per individual, like phones, wearables, and smart home items, which we use for entertainment, communication, quality of life, and so on.
+
+It is in this context that mobile software development becomes super-important.
+
+We said earlier that, no matter what job you will have, you will write code. We can add to that: you will likely write code for mobile devices. There are more than 15 billion mobile devices operating worldwide, and that number is only going up. As Gordon Bell said, this leads to new usage patterns.
+
+We access the Internet more often from our mobile than our desktop or laptop. Most of the digital content we consume we do so on mobiles. We spend hours a day on our mobile, and the vast majority of that time we spend in apps, not on websites.
+
+A simple example of a major change in how we use computing and communication is social media. Most of the world's population uses it. It changes how we work. Even the professional workforce is increasingly dependent on mobiles, for this reason.
+
+### Mobile vs. desktop: Applications
+
+There are many differences between how we write applications for a mobile device vs. a desktop computer. On a desktop, applications can do pretty much whatever they want, whereas, on a mobile, each app is super-specialized. On the desktop, users explicitly starts applications; on mobile, the difference between running or not is fluid: apps can be killed anytime, and they need to be ready to restart.
+
+On a desktop, you typically have multiple applications active in the foreground, with multiple windows on-screen. The mobile experience is difference: a user's interaction with an app doesn't always begin in the same place, but rather the user's journey often begins non-deterministically. As a result, a mobile app has a more complex structure than a traditional desktop application, with multiple types of components and entry points.
+
+The execution model on mobiles is more cooperative than on a desktop. For example, a social media app allows you to compose an email, and does so by reusing the email app. Another example is something like WhatsApp, which allows you to take pictures (and does so by asking the Photo app to do it). In essence, apps request services from other apps, and they build upon the functionality of others, which is fundamentally difference from the desktop application paradigm.
+
+### Mobile vs. desktop: Operating environment
+
+One of the biggest differences is in the security model. Think of your parents' PC at home or in an Internet café: there are potentially multiple users that don’t trust each other, each have specific file permissions, every application by default inherits all of a user's permissions, all applications are trusted to run with user's privileges alongside each other. The operating system prevents one application from overwriting others, but does not protect the I/O resources (e.g., files). One could fairly say that security is somewhat of an afterthought on the desktop.
+
+A mobile OS has considerably stronger isolation. The assumption here is that users might naively install malicious apps, and the goal is to protect users’ data (and privacy) even when they do stupid things. So, each mobile app is sandboxed separately.
+
+When you install a mobile app, it will ask the device for necessary permissions, like access to contacts, camera, microphone, location information, SMS, WiFi, user accounts, body sensors, etc.
+
+A mobile device is more constrained, e.g., you don't really get ""root"" access. It provides strong hardware-based isolation and powerful authentication features (like face recognition). E.g., for iPhone's FaceID, the face scan pattern is encrypted and sent to a secure hardware ""enclave"" in the CPU, to make sure that stored facial data is inaccessible to any party, including Apple.
+
+Power management is a first-class citizen in a mobile OS. While PCs use high-power CPUs and GPUs with heatsinks, smartphones and tablets are typically not plugged in, so they cannot provide sustained high power. On a mobile, the biggest energy hog is typically the screen, whereas in a desktop it is the CPU and GPU.
+
+Desktop OSes tend to be generic, whereas mobile OSes specialize for a given set of mobile devices, so they can have strict hardware requirements. This leads to less backward compatibility, and so the latest apps will not run on older versions of the OS, and new versions of a mobile OS won't run on older devices.
+
+There is also orders-of-magnitude less storage on mobiles, and orders-of-magnitude less memory. Plus, you cannot easily expand / modify storage and memory.
+
+Mobile networking tends to be more intermittent than in-wall connectivity. An Ethernet connections gives you Gbps, while a WiFi connection gives you Mbps.
+
+On a desktop, the input comes typically from a keyboard and a mouse, whereas mobiles have small touch keyboards, voice commands, complex gestures, etc. Output is also limited on mobiles, so often they communicate with other devices to achieve their output.
+
+We are witnessing today a convergence between desktop and mobile OSes, which will gradually make desktops disappear, and computing will become increasingly more embedded.
+
+### Challenges and opportunities
+
+This new world of mobile presents both opportunities and challenges.
+
+Users are many more, and are more diverse. They have widely differing computer skills. Developers need to focus on ease of use, internationalization, and accessibility.
+
+Platforms are more diverse (think phones, wearables, TVs, cars, e-book readers). Different vendors take different approaches to dealing with this diversity: Apple has the ""walled garden"" approach, while Android is more like the wild west: Android is open-source, so OEMs (original equipment manufacturers) can customize Android to their devices, so naturally Android runs on tens of thousands of models of devices today.
+
+Mobiles get interesting new kinds of inputs, from multi-touch screens, accelerometers, GPS. But they also face serious limitations in terms of screen size, processor power, and battery capacity.
+
+Mobile devices need to (and can be) managed more tightly. Today you can remote-lock a device, you can locate the device, and with software like MDM (mobile device management) you can do everything on the device remotely. Some mobile carriers even block users from installing certain apps on their devices.
+
+App stores or Play stores are digital storefronts for content consumed on device. Today, the success of a mobile platform depends heavily on its app store, which becomes a central hub for content to be consumed on that particular mobile platform. The operator of the store controls apps published in the store (e.g., disallow sexually explicit content, violence, hate speech, anything illegal), which means that the developer needs to be aware of rules and laws in the places where app will be used. Operators typically use automated tools and human reviewers to check apps for malware and terms-of-service violations.
+
+## How does a mobile operating environment work?
+
+A mobile device aims to achieve seemingly contradictory goals: On the one hand, it aims for greater integration than a desktop, to create a more cooperative ecosystem in which to enable apps to provide services to each other. On the other hand, it aims for greater isolation, it wants to offer a stronger sandbox, to protect user data, and to restrict apps from interacting in more complex ways
+
+Each mobile OS makes its own choices for how to do this. In this lecture, we chose to focus on Android, for three reasons:
+
+* it is open-source, so it's easier to understand what it really does
+* over 70% of mobiles use Android, there are more than 2.5 billion Android users and more than 3 billion active Android devices, so this is very real
+* we will use it in the follow-on course [Software Development Project](https://dslab.epfl.ch/teaching/sweng/proj)
+
+Android is based on Linux, and things like multi-threading and low-level memory management are all provided by the Linux kernel. There is a layer, called the hardware abstraction layer (HAL), that provides standard interfaces to specific hardware capabilities, such as the camera or the Bluetooth module. Whenever an application makes a call to access device hardware, Android loads a corresponding library module from the HAL for that hardware component.
+
+Above the HAL, there is the Android runtime (ART) and the Native C/C++ libraries.
+
+The ART provides virtual machines for executing DEX (Dalvik executable) bytecode, which is specially designed to have a minimal memory footprint. Java code gets turned into DEX bytecode, which can run on the ART.
+
+Android apps can be written in Kotlin, Java, or even C++. The Android SDK (software development kit) tools compile code + resource files into a so-called Android application package (APK), which is an archive used to install the app. When publishing to the Google Play app store, one generates instead an Android app bundle (ABB), and then Google Play itself generates optimized APKs for the target device that is requesting installation of the app. This is a more practical approach than having the developer produce individual APKs for each device.
+
+Each Android app lives in its own security sandbox. In Linux terms, each app gets its own user ID. Permissions for all the files accessed by the app are set so that only the assigned user ID can access them. It is possible for apps to share data and access each other's files, in which case they get the same Linux user ID; the apps however must be from the same developer (i.e., signed with the same developer certificate).
+
+Each app runs in its own Linux process. By default, an app can access only the components that it needs to do its work and no more (this follows the [principle of least privilege](https://en.wikipedia.org/wiki/Principle_of_least_privilege)). An app can access the device's location, camera, Bluetooth connection, etc. as long as the phone user has explicitly granted it these permissions. Each app has its own instance of the ART, with its own VM to execute DEX bytecode. In other words, apps don't run inside a common VM.
+
+In Android, the UI is privileged. Foreground and UI threads get higher priority in CPU scheduling than the other threads. Android uses process containers (a.k.a., [Linux cgroups](https://en.wikipedia.org/wiki/Cgroups)) to allocate a higher percentage of the CPU to them. When users switch between apps, Android keeps non-foreground apps (e.g., not visible to the user) in a cache (in Linux terms, the corresponding processes do not terminate) and, if the user returns to the app, the process is reused, which makes app switching faster.
+
+Many core system components (like the ART and HAL) require native libraries written in C/C++. Android provides Java APIs to expose the functionality of these native libraries to apps. This Java APIs framework is layered on top of the ART and native C/C++ libraries. Apps written in C/C++ can use the native libraries directly (this requires the Android native development kit, or NDK).
+
+Within the Java API framework, there are a number of Android features provided through APIs written in Java that provide key building blocks for apps. For example, the View System is used for building the UI. E.g., the Resource Manager is used by apps for accessing localized strings or graphics. E.g., the Activity Manager handles the lifecycle of apps and provides a common navigation back stack (more on this below). And, as a final example, Content Providers enable apps to access data from other apps (e.g., a social media app access the Contacts app) or to share their own data.
+
+On top of this entire stack are the apps. Android comes with core apps for email, SMS, calendaring, web browsing, contacts, etc. but these apps have no special status, then can be replaced with third-party apps. The point of shipping them with Android is to provide key capabilities to other apps out of the box (e.g., allow multiple apps to have the functionality of sending an SMS without having to write the code for it).
+
+An Android app is a collection of components, with each component providing an entry point to the app. There are 4 main components:
+
+* An _Activity_ provides an entry point with a UI, for interacting with the user. An activity represents a single screen with a user interface. For example, an email app has an activity to show a list of new emails, another activity to compose an email, another activity to read emails, and so on -- activities work together to form the email app, but each one is independent of the others. Unlike in desktop software, other apps can start any one of these activities if the email app allows it, e.g., the Camera app may start the compose-email activity in order to send a picture by email.
+* A _Service_ is a general-purpose entry point without a UI. This essentially keeps an app running in the background (e.g., play music in the background while the user is in a different app, or fetch data over the network without blocking user interaction with an activity). A service can also be started by another component.
+* A _Broadcast Receiver_ enables Android to deliver events to apps out-of-band, e.g., an app may set a timer and ask Android to wakes it up at some point in the future; this way, the app need not run non-stop until then. So broadcasts can be delivered even to apps that aren't currently running. Broadcast events can be initiated by the OS (e.g., the screen turned off, battery is low, picture was taken) or can be initiated by apps (e.g., some data has been downloaded and is available for other apps to use). Broadcast receivers have no UI, but they can create a status bar notification to alert the user.
+* A _Content Provider_ manages data that is shared among apps. Such data can be local (e.g., file system, SQLite DB) or remote on some server. Through a content provider, apps can query / modify the data (e.g., the Contacts data is a content provider: any app with the proper permissions can get contact info and can write contact info).
+
+Remember that any app can cause another app’s component to start. For instance, if WhatsApp wants to take a photo with the camera, it can ask that an activity be started in the Camera app, without the WhatsApp developer having to write the code to take photos--when done, the photo is returned to WhatsApp, and to the user it appears as if the camera is actually a part of WhatsApp.
+
+To start a component, Android starts the process for target app (if not already running), instantiates the relevant classes (this is because, e.g., the photo-taking activity runs in the Camera process, not WhatsApp's process). You see here an example of multiple entry points: there is no `main()` like in a desktop app.
+
+Then, to activate a component in another app, you must create an _Intent_ object, which is essentially a message that activates either a specific component (explicit intent) or a type of component (implicit intent). For activities and services, the intent defines the action to perform (e.g., view or send something) and specifies the URI of the data to act on (e.g., this is an intent to dial a certain phone number). If the activity returns a result, it is returned in an Intent (e.g., let the user pick a contact and return a URI pointing to it). For broadcast receivers, the intent defines the announcement being broadcast (e.g., if battery is low it includes the BATTERY_LOW string), and a receiver can register for it by filtering on the string. Content providers are not activated by intents but rather when targeted by a request from what's called a Content Resolver, which handles all interaction with the content provider.
+
+## A mobile app: Structure and lifecycle
+
+The centerpiece of an Android app is the _activity_. Unlike the kinds of programs you've been writing so far, there is no `main()`, but rather the underlying OS initiates code in an _Activity_ by invoking specific callback methods.
+
+An activity provides the window in which the app draws its UI. One activity essentially implements one screen in an app, e.g., 1 activity for a Preferences screen, 1 activity for a Select Photo screen, etc.
+
+Apps contain multiple screens, each of which corresponds to an activity. One activity is specified as the main activity, i.e., the first screen to appear when you launch the app. Each activity can then start another activity, e.g., the main activity in an email app may provide the screen that shows your inbox, then you have screens for opening and reasing a message, one for writing, etc.
+
+As a user navigates through, out of, back into an app, the activities in the app transition through diff states. Transitioning from one state to another is handled by specific callbacks that must be implemented in the activity. The activity learns about changes and reacts to when the user leaves and re-enters the activity: For example, a streaming video player will likely pause the video and terminate the network connection when the user switches to another app; when the user returns to the app, it will reconnect to the network and allow the user to resume the video from the same spot.
+
+To understand the lifecycle of an activity, please see [the Android documentation](https://developer.android.com/guide/components/activities/activity-lifecycle).
+
+Another important element are _fragments_. These provide a way to modularize an activity's UI and reuse modules across different activities. This provides a productive and efficient way to respond to various screen sizes, or whether your phone is in portrait or landscape mode, where the UI is composed differently but from the same modules.
+
+A fragment may show the list of emails, and another fragment may display an email thread. On a phone, you would display only one at a time, and upon tap switch to the next activity. On a tablet, with the greater screen real estate, you have room for both. By modularizing the UI into fragments, it's easy to adapt the app to the different layouts by rearranging fragments within the same view when the phone switches from portrait to landscape mode.
+
+To understand fragments, please see [the Android documentation](https://developer.android.com/guide/fragments).
+
+You don't have to use fragments within activities, but such modularization makes the app more flexible and also makes it easier to maintain over time. A fragment defines and manages its own layout, has its own lifecycle, and can handle its own input events. But it cannot live on its own, it needs to be hosted by an activity or another fragment.
+
+Android beginners tend to put all their logic inside Activities and Fragments, ending up with ""views"" that do a lot more than just render the UI. Remember what we said about MVVM and how that maps to how you build an Android app. In the exercise set, we will ask you to go through an MVVM exercise. Android provides a nice ViewModel class to store and manage UI-related data.
+
+## User experience (UX)
+
+User experience design (or ""UX design"") is about putting together an intuitive, responsive, navigable, usable interface to the app. You want to look at the app through the users' perspective to derive what can give them an easy, logical and positive experience.
+
+So you must ask who is your audience: Old or young people? Intellectuals or blue-collar workers? Think back to the lecture on personas and user stories.
+
+The UI should enable the user to get around the app easily, and to find quickly what they're looking for. To achieve this, several elements and widgets have emerged from the years of experience of building mobile apps. The [hamburger icons](https://en.wikipedia.org/wiki/Hamburger_button) are used for drop-down menus with further details--they avoid clutter. Home buttons give users a shortcut to home base. Chat bubbles offer quick help through context-sensitive messages.
+
+Personalization of the UI allows adapting to what the user is interested in, keeping the unrelated content away. For example, in the [EPFL Campus app](https://pocketcampus.org/epfl-en) you can select which features you see on the home screen, and so the home screen of two different users is likely to look different.
+
+In order to maximize readability, emphasize simplicity and clarity, choose adequate font size and image size. Avoid having too many elements on the screen, because that leads to confusion. Offer one necessary action per screen. Use [micro UX animations](https://uxplanet.org/ui-design-animations-microinteractions-50753e6f605c), which are little animations that appear when a specific action is performed or a particular item is hovered or touched; this can increase engagement and interactivity. E.g., hovering over a thumbnail shows details about it. E.g., hover zoom for maximizing the view of a specific part of something. Keep however the animations minimal, avoid flashiness, make them subtle and clear as to their intent.
+
+Keep in mind _thumb zones_. People use their mobile when they’re standing, walking, riding a bus, so the app should allow them to hold the device and view its screen and provide input in all these situations. So make it easy for the user to reach with their thumb the stuff they do most often. Leverage gesture controls to make it easy for a user to interact with apps--e.g., “holding” an item, “dragging” it to a container, and then “releasing”--but beware to do what users of that device are used to doing, not exotic stuff.
+
+Think of augmented reality and voice interaction, depending on the app, they can be excellent ways to interact with the device.
+
+## The mobile ecosystem
+
+A modern mobile app, no matter how good it is, can hardly survive without plugging into its ecosystem.
+
+Most mobile apps are consists of the phone side of the app and the cloud side. Apps interact with cloud services typically over REST APIs, which is an architectural style that builds upon HTTP and JSON to offer CRUD (copy-read-update-delete) operations on objects that are addressed by a URI. You use HTTP methods to access these resources via URL-encoded parameters.
+
+Aside from the split architecture, apps also interact with the ecosystem through Push notifications. These are automated messages sent to the user by the server of the app that’s working in the background (i.e., not currently open). Each OS (e.g., Android, iOS) has its own push notification service with a specific API that apps can use, and they each operate a push engine in the cloud.
+
+The app developer enables their app with push notifications, at which point the app can start receiving incoming notifications. When you open the app, unique IDs for both the app and the device are created by the OS and registered with the OS push notification service. IDs are passed back to the app and also sent to the app publisher. The in-cloud service generates the message (either when a publisher produces it, or in response to some event, etc.) which can be targeted at users or a group of users and gets sent to the corresponding mobile. On Android, an incoming notification can create an Activity.
+
+A controversial aspect of the ecosystem is the extent to which it track the device and the user of the device. We do not discuss this aspect here in detail, it is just something to be aware of.
+
+A key ingredient of ""plugging into"" the ecosystem is the network. Be aware that your users may experience different bandwidth limitations (e.g., 3G vs. 5G), and the Internet doesn't work as smoothly everywhere in the world as we're used to. In addition to bandwidth issues, there is also the risk of experiencing a noticeable disconnection from the Internet. E.g., a highly interactive, graphic-heavy app will not be appropriate for apps that target Latin America or Africa, or users in rural areas, because today there are still many areas with spotty connectivity.
+
+Perhaps a solution can be offered by the new concept of fog computing (as opposed to cloud computing), also called edge computing. It is about the many ""peripheral"" devices that connect to the periphery of a cloud, and many of these devices will generate lots of raw data (e.g., from sensors). Rather than forward this data to cloud-based servers, one could do as much processing as possible using computing units nearby, so that processed rather than raw data is forwarded to the cloud. As a result, bandwidth requirements are reduced. ""The Fog"" can support the Internet of Things (IoT), including phones, wearable health monitoring devices, connected vehicle and augmented reality devices. IoT devices are often resource-constrained and have limited computational abilities to perform, e.g., cryptography computations, so a fog node nearby can provide security for IoT devices by performing these cryptographic computations instead.
+
+## Summary
+
+In this lecture, you learned:
+
+* Several ways in which a desktop app differs from a mobile app
+* How security, energy, and other requirements change when moving from a desktop to a mobile
+* How activities and fragments work in Android apps
+* The basics of good UX
+* How mobile apps can leverage their ecosystem
+
+You can now check out the [exercises](exercises/).
+",CS-305: Software engineering
+"# Evolution
+
+Imagine you are an architect asked add a tower to a castle.
+You know what towers look like, you know what castles look like, and you know how to build a tower in a castle. This will be easy!
+
+But then you get to the castle, and it looks like this:
+
+Suggestions (click to expand)
++ +The changes necessary are similar to those we discussed above, including injecting an `HttpClient` dependency and making the function return a `String`. +We provide [an example `JokeFetcher`](exercises/solutions/lecture/JokeFetcher.java), [an example `App`](exercises/solutions/lecture/App.java), +and [tests](exercises/solutions/lecture/JokeFetcherTests.java). + +
+
+
+
+
+## Where to start in a large codebase?
+
+Refactorings are useful for specific parts of code, but where to even start if you are given a codebase of millions of lines of code and told to fix a bug?
+There may not be documentation, and if there is it may not be accurate.
+
+A naïve strategy is to ""move fast and break things"", as [was once Facebook's motto](https://www.businessinsider.com/mark-zuckerberg-on-facebooks-new-motto-2014-5).
+The advantage is that you move fast, but... the disadvantage is that you break things.
+The latter tends to massively outweigh the former in any large codebase with many users.
+Making changes you don't fully understand is a recipe for disaster in most cases.
+
+An optimistic strategy, often taken by beginners, is to understand _everything_ about the code.
+Spend days and weeks reading every part of the codebase. Watch video tutorials about every library the code uses.
+This is not useful either, because it takes far too long, and because it will in fact never finish since others are likely making changes to the code while you learn.
+Furthermore, by the time you have read half the codebase, you won't remember what exactly the first part you looked at was, and your time will have been wasted.
+
+Let's see three components of a more realistic strategy: learning as you go, using an IDE, and taking notes.
+
+### Learning as you go
+
+Think of how detectives such as [Sherlock Holmes](https://en.wikipedia.org/wiki/Sherlock_Holmes) or [Miss Marple](https://en.wikipedia.org/wiki/Miss_Marple) solve a case.
+They need information about the victim, what happened, and any possible suspects, because that is how they will find out who did it.
+But they do not start by asking every person around for their entire life story from birth to present.
+They do not investigate the full history of every item found at the scene of the crime.
+While the information they need is somewhere in there, getting it by enumerating all information would take too much time.
+
+Instead, detectives only learn what they need when they need it. If they find evidence that looks related, they ask about that evidence.
+If somebody's behavior is suspect, they look into that person's general history, and if something looks related, they dig deeper for just that detail.
+
+This is what you should do as well in a large codebase. Learn as you go: only learn what you need when you need it.
+
+### Using an IDE
+
+You do not have to manually read through files to find out which class is used where, or which modules call which function.
+IDEs have built-in features to do this for you, and those features get better if the language you're using is statically typed.
+Want to find who uses a method? Right click on the method's name, and you should find some tool such as ""find all references"".
+Do you realize the method is poorly named given how the callers use it? Refactor its name using your IDE, don't manually rename every use.
+
+One key feature of IDEs that will help you is the _debugger_.
+Find the program's ""main"" function, the one called at the very beginning, and put a breakpoint on its first statement.
+Run the program with the debugger, and you're ready to start your investigation by following along with the program's flow.
+Want to know more about a function call? Step into it. Think that call is not relevant right now? Step over it instead.
+
+### Taking notes
+
+You cannot hope to remember all context about every part of a large codebase by heart.
+Instead, take notes as you go, at first for yourself. You may later turn these notes into documentation.
+
+One formal way to take notes is to write _regression tests_.
+You do not know what behavior the program should have, but you do know that it works and you do not want to break it.
+Thus, write a test without assertions, run the test under the debugger, and look at the code's behavior.
+Then, add assertions to the test for the current behavior.
+This serves both as notes for yourself of what happens when the code is used in a specific way, and as an automated way to check if you broke something while modifying the code later.
+
+Another formal way to take notes is to write _facades_.
+""Facade"" is a design pattern intended to simplify and modularize existing code by hiding complex parts behind simpler facades.
+For instance, let's say you are working in a codebase that only provides a very generic ""draw"" method that takes a lot of arguments, but you only need to draw rectangles:
+```java
+var points = new Point[] {
+ new Point(0, 0), new Point(x, 0),
+ new Point(x, y), new Point(0, y)
+};
+draw(points, true, false, Color.RED, null, new Logger(), ...);
+```
+This is hard to read and maintain, so write a facade for it:
+```java
+drawRectangle(0, 0, x, y, Color.RED);
+```
+Then implement the `drawRectangle` method in terms of the complex `draw` method.
+The behavior hasn't changed, but the code is easier to read.
+Now, you only need to look at the complex part of the code if you actually need to add functionality related to it.
+Reading the code that needs to draw rectangles no longer requires knowledge of the complex drawing function.
+
+---
+#### Exercise
+Take a look at the [pacman/](exercises/lecture/pacman) exercise folder.
+It's a cool ""Pac-Man"" game written in Java, with a graphical user interface.
+It's fun! Imagine you were asked to maintain it and add features. You've never read its code before. so where to start?
+
+First, look at the code, and take some notes: which classes exist, and what do they do?
+Then, use a debugger to inspect the code's flow, as described above.
+If someone asked you to extend this game to add a new kind of ghost, with a different color and behavior, which parts of the code would you need to change?
+Finally, what changes could you make to the code to make it easier to add more kinds of ghosts?
+
+Proposed solution (click to expand)
++ +The code tries to model the quality of items over time. But it has so many special cases and so much copy-pasted code that it's hard to tell. + +Some possible refactorings: +- Turn the `for (int i = 0; i < items.length; i++)` loop into a simpler `for (Item item : items)` loop +- Simplify `item.quality = item.quality - item.quality` into the equivalent but clearer `item.quality = 0` +- Extract `if (item.quality < 50) item.quality = item.quality + 1;` into a method `incrementQuality` on `Item`, which can thus encapsulate this cap at 50 +- Extract numbers such as `50` into named constants such as `MAX_QUALITY` +- Extract repeated checks such as those on the item names into methods on `Item` such as `isPerishable`, and maybe create subclasses of `Item` instead of checking names + +
+
+
+
+---
+
+Remember the rule typically used by scouts: leave the campground cleaner than you found it.
+In your case, the campground is code.
+Even small improvements can pay off with time, just like monetary investments.
+If you improve a codebase by 1% every day, after 365 days, it will be around 38x better than you started.
+But if you let it deteriorate by 1% instead, it will be only 0.03x as good.
+
+
+## How should we document changes?
+
+You've made some changes to legacy code, such as refactorings and bug fixes. Now how do you document this?
+The situation you want to avoid is to provide no documentation, lose all knowledge you gained while making these changes, and need to figure it all out again. This could happen to yourself or to someone else.
+
+Let's see three kinds of documentation you may want to write: for yourself, for code reviewers, and for maintainers.
+
+### Documenting for yourself
+
+The best way to check and improve your understanding of a legacy codebase is to teach others about it, which you can do by writing comments and documentation.
+This is a kind of ""refactoring"": you improve the code's maintainability by writing the comments and documentation that good code should have.
+
+For instance, let's say you find the following line in a method somewhere without any explanation:
+```java
+if (i > 127) i = 127;
+```
+After spending some time on it, such as commenting it out to see what happens, you realize that this value is eventually sent to a server which refuses values above 127.
+You can document this fact by adding a comment, such as `// The server refuses values above 127`. You now understand the code better.
+Then you find the following method:
+```java
+int indexOfSpace(String text) { ... }
+```
+You think you understand what this does, but when running the code, you realize it not only finds spaces but also tabs.
+After some investigation, it turns out this was a bug that is now a specific behavior on which clients depend, so you must keep it.
+You can thus add some documentation: `Also finds tabs. Clients depend on this buggy behavior`.
+You now understand the code better, and you won't be bitten by this issue again.
+
+### Documenting for code reviewers
+
+You submit a pull request to a legacy codebase. Your changes touch code that your colleagues aren't quite familiar with either.
+How do you save your colleagues some time? You don't want them to have to understand exactly what is going on before being able to review your change,
+yet if you only give them code, this is what will happen.
+
+First, your pull request should have a _description_, in which you explain what you are changing and why.
+This description can be as long as necessary, and can include remarks such as whether this is a refactoring-only change or a change in behavior,
+or why you had to change some code that intuitively looks like it should not need changes.
+
+Second, the commits themselves can help reviewing if you split your work correctly, or if you rewrite the history once you are done with the work.
+For instance, your change may involve a refactoring and a bug fix, because the refactoring makes the bug fix cleaner.
+If you submit the change as a single commit, reviewers will need time and energy to read and understand the entire change at once.
+If a reviewer is interrupted in the middle of understanding that commit, they will have to start from scratch after the interruption.
+
+Instead of one big commit, you can submit a pull request consisting of one commit per logical task in the request.
+For instance, you can have one commit for a refactoring, and one for a bug fix. This is easier to review, because they can be reviewed independently.
+This is particularly important for large changes: the time spent reviewing a commit is not linear in the length of the commit, but closer to exponential,
+because we humans have limited brain space and usually do not have large chunks of uninterrupted time whenever we'd like.
+Instead of spending an hour reviewing 300 modified lines of code, it's easier to spend 10 times 3 minutes reviewing commits of 30 lines at a time.
+This also lessens the effects of being interrupted during a review.
+
+### Documenting for maintainers
+
+We've talked about documentation for individual bits of code, but future maintainers need more than that to understand a codebase.
+Design decisions must be documented too: what did you choose and why?
+Even if you plan on maintaining a project yourself for a long time, this saves some work: your future colleagues could each take 5 minutes of your time asking
+you the same question about some design decision taken long ago, or you could spend 10 minutes once documenting it in writing.
+
+At the level of commits, this can be done in a commit message, so that future maintainers can use tools such as [git blame](https://git-scm.com/docs/git-blame)
+to find the commit that last changed a line of code and understand why it is that way.
+
+At the level of modules or entire projects, this can be done with _Architectural Decision Records_.
+As their name implies, these are all about recording decisions made regarding the architecture of a project: the context, the decision, and its consequences.
+The goal of ADRs is for future maintainers to know not only what choices were made but also why, so that maintainers can make an informed decision on whether to make changes.
+For instance, knowing that a specific library for user interfaces was chosen because of its excellent accessibility features informs maintainers that even if they do not like
+the library's API, they should pay particular attention to accessibility in any potential replacement. Perhaps the choice was made at a time when alternatives had poor accessibility,
+and the maintainers can change that choice because in their time there are alternatives that also have great accessibility features.
+
+The context includes user requirements, deadlines, compatibility with previous systems, or any other piece of information that is useful to know to understand the decision.
+For instance, in the context of lecture notes for a course, the context could include ""We must provide lecture notes, as student feedback tells us they are very useful""
+and ""We want to allow contributions from students, so that they can easily help if they find typos or mistakes"".
+
+The decision includes the alternatives that were considered, the arguments for and against each of them, and the reasons for the final choice.
+For instance, still in the same context, the alternatives might be ""PDF files"", ""documents on Google Drive"", and ""documents on a Git repository"".
+The arguments could then include ""PDF files are convenient to read on any device, but they make it hard to contribute"".
+The final choice might then be ""We chose documents on a Git repository because of the ease of collaboration and review, and because GitHub provides a nice preview of Markdown files online"".
+
+The consequences are the list of tasks and changes that must be done in the short-to-medium term.
+This is necessary to apply the decision, even if it may not be useful in the long term.
+For instance, one person might be tasked with converting existing lecture notes to Markdown, and another might be tasked to create an organization and a repository on GitHub.
+
+It is important to keep ADRs _close to the code_, such as in the same repository, or in the same organization on a platform like GitHub.
+If ADRs are in some unrelated location that only current maintainers know about, they will be of no use to future maintainers.
+
+
+## How can we quantify changes?
+
+Making changes is not only about describing them qualitatively, but also about telling people who use the software whether the changes will affect them or not.
+For instance, if you publish a release that removes a function from your library, people who used that function cannot use this new release immediately.
+They need to change their code to no longer use the function you removed, which might be easy if you provided a replacement, or might require large changes if you did not.
+And if the people using your library cannot or do not want to update their software, for instance because they have lost the source code, they now have to rewrite their software.
+
+Let's talk _compatibility_, and specifically three different axes: theory vs practice, forward vs backward, and source vs binary.
+
+### Theory vs practice
+
+In theory, any change could be an ""incompatible"" change.
+Someone could have copied your code or binary somewhere, and start their program by checking that yours is still the exact same one. Any change would make this check fail.
+Someone could depend on the exact precision of some computation whose precision is not documented, and then [fail](https://twitter.com/stephentyrone/status/1425815576795099138)
+when the computation is made more precise.
+
+In practice, we will ignore the theoretical feasibility of detecting changes and choose to be ""reasonable"" instead.
+What ""reasonable"" is can depend on the context, such as Microsoft Windows having to provide compatibility modes for all kinds of old software which did questionable things.
+Microsoft must do this because one of the key features they provide is compatibility, and customers might move to other operating systems otherwise.
+Most engineers do not have such strict compatibility requirements.
+
+### Forward vs backward
+
+A software release is _forward compatible_ if clients for the next release can also use it without needing changes.
+This is also known as ""upward compatibility"".
+That is, if a client works on version N+1, forward compatibility means it should also work on version N.
+Forward compatibility means that you cannot ever add new features or make changes that break behavior,
+since a client using those new features could not work on the previous version that did not have these features.
+It is rare in practice to offer forward compatibility, since the only changes allowed are performance improvements and bug fixes.
+
+A software release is _backward-compatible_ if clients for the previous release can also use it without needing changes.
+That is, if a client works on version N-1, backward compatibility means it should also work on version N.
+Backward compatibility is the most common form of compatibility and corresponds to the intuitive notion of ""don’t break things"".
+If something works, it should continue working. For instance, if you upgrade your operating systems, your applications should still work.
+
+Backward compatibility typically comes with a set of ""supported"" scenarios, such as a public API.
+It is important to define what is supported when defining compatibility, since otherwise some clients could misunderstand what is and is not supported,
+and their code could break even though you intended to maintain backward compatibility.
+For instance, old operating systems did not have memory protection: any program could read and write any memory, including the operating system's.
+This was not something programs should have been doing, but they could. When updating to a newer OS with memory protection, this no longer worked,
+but it was not considered breaking backward compatibility since it was never a feature in the first place, only a limitation of the OS.
+
+One extreme example of providing backward compatibility is Microsoft's [App Assure](https://www.microsoft.com/en-us/fasttrack/microsoft-365/app-assure):
+if a company has a program that used to work and no longer works after upgrading Windows, Microsoft will fix it, for free.
+This kind of guarantee is what allowed Microsoft to dominate in the corporate world; no one wants to have to frequently rewrite their programs,
+no matter how much ""better"" or ""nicer"" the new technologies are. If something works, it works.
+
+### Source vs binary
+
+Source compatibility is about whether your customers' source code still compiles against a different version of your code.
+Binary compatibility is about whether your customers’ binaries still link with a different version of your binary.
+These are orthogonal to behavioral compatibility; code may still compile and link against your code even though the behavior at run-time has changed.
+
+Binary compatibility can be defined in terms of ""ABI"", ""Application Binary Interface"", just like ""API"" for source code.
+The ABI defines how components call each other, such as method signatures: method names, return types, parameter types, and so on.
+The exact compatibility requirements differ due to the ABI of various languages and platforms.
+For instance, parameter names are not a part of Java's ABI, and thus can be changed without breaking binary compatibility.
+In fact, parameter names are not a part of Java's API either, and can thus also be changed without breaking source compatibility.
+
+An interesting example of preserving source but not binary compatibility is C#'s optional parameters.
+A definition such as `void Run(int a, int b = 0)` means the parameter `b` is optional with a default value of `0`.
+However, this is purely source-based; writing `Run(a)` is translated by the compiler as if one had written `Run(a, 0)`.
+This means that evolving the method from `void Run(int a)` to `void Run(int a, int b = 0)` is compatible at the source level,
+because the compiler will implicitly add the new parameter to all existing calls, but not at the binary level, because the method signature changed so existing binaries will not find the one they expect.
+
+An example of the opposite is Java's generic type parameters, due to type erasure.
+Changing a class from `WidgetProposed solution (click to expand)
++ +To add a kind of ghost, you'd need to add a value to the `ghostType` enum, and a class extending `Ghost`. +You would then need to add parsing logic in `MapEditor` for your ghost, and to link the enum and class together in `PacBoard`. + +To make the addition of more ghosts easier, you could start by re-formatting the code to your desired standard, and changing names to be more uniform, such as the casing of `ghostType`. +One task would be to have a single object to represent ghosts, instead of having both `ghostType` and `Ghost`. +It would also probably make sense to split the parsing logic from `MapEditor`, since editing and parsing are not the same job. + +Remember, you might look at this Pac-Man game code thinking it's not as nice as some idealized code that could exist, but unlike the idealized code, this one does exist already, and it works. +Put energy into improving the code rather than complaining about it. + +
+
+
+
+---
+
+What compatibility guarantees should you provide, then?
+This depends on who your customers are, and asking them is a good first step.
+Avoid over-promising; the effort required to maintain very strict compatibility may be more than the benefits you get from the one or two specific customers who need this much compatibility.
+Most of your customers are likely to be ""reasonable"".
+
+Backward compatibility is the main guarantee people expect in practice, even if they do not say so explicitly.
+Breaking things that work is viewed poorly.
+However, making a scenario that previously had a ""failure"" result, such as throwing an exception, return a ""success” result instead is typically OK.
+Customers typically do not depend on things _not_ working.
+
+
+## How can we establish solid foundations?
+
+You are asked to run an old Python script that a coworker wrote ages ago.
+The script begins with `import simplejson`, and then proceeds to use the `simplejson` library.
+You download the library, run the script... and you get a `NameError: name 'scanstring' is not defined`.
+
+Unfortunately, because the script did not specify what _version_ of the library it expected, you now have to figure it out by trial and error.
+For crashes such as missing functions, this can be done relatively quickly by going through versions in a binary search.
+However, it is also possible that your script will silently give a wrong result with some versions of the library.
+For instance, perhaps the script depends on a bug fix made at a specific time,
+and running the script with a version of the library older than that will give a result that is incorrect but not obviously so.
+
+Versions are specific, tested, and named releases.
+For instance, ""Windows 11"" is a version, and so is ""simplejson 3.17.6"".
+Versions can be more or less specific; for instance, ""Windows 11"" is a general product name with a set of features, and some more minor features were added in updates such as ""Windows 11 22H2"".
+
+Typical components of a version include a major and a minor version number, sometimes followed by a patch number and a build number;
+a name or sometimes a codename; a date of release; and possibly even other information.
+
+In typical usage, changing the major version number is for big changes and new features,
+changing the minor version number is for small changes and fixes, and changing the rest such as the patch version number is for small fixes that may not be noticeable to most users,
+as well as security patches.
+
+Versioning schemes can be more formal, such as [Semantic Versioning](https://semver.org/),
+a commonly used format in which versions have three main components: `Major.Minor.Patch`.
+Incrementing the major version number is for changes that break compatibility, the minor version number is for changes that add features while remaining compatible,
+and the patch number is for compatible changes that do not add features.
+As already stated, remember that the definition of ""compatible"" changes is not objective.
+Some people may consider a change to break compatibility even if others think it is compatible.
+
+Let's see three ways in which you will use versions: publishing versioned releases, _deprecating_ public APIs if truly necessary, and consuming versions of your dependencies.
+
+### Versioning your releases
+
+If you allowed customers to download your source code and compile it whenever they want,
+it would be difficult to track who is using what, and any bug report would start with a long and arduous process of figuring out exactly which version of the code is in use.
+Instead, if a customer states they are using version 5.4.1 of your product and encounter a specific bug, you can immediately know which code this corresponds to.
+
+Providing specific versions to customers means providing specific guarantees, such as ""version X of our product is compatible with versions Y and Z of the operating system"",
+or ""version X of our product will be supported for 10 years with security patches"".
+
+You do not have to maintain a single version at a time; products routinely have multiple versions under active support,
+such as [Java SE](https://www.oracle.com/java/technologies/java-se-support-roadmap.html).
+
+In practice, versions are typically different branches in a repository.
+If a change is made to the ""main"" branch, you can then decide whether it should be ported to some of the other branches.
+Security fixes are a good example of changes that should be ported to all versions that are still supported.
+
+### Deprecating public APIs
+
+Sometimes you realize your codebase contains some very bad mistakes that lead to problems,
+and you'd like to correct them in a way that technically breaks compatibility but still leads to a reasonable experience for your customers.
+That is what _deprecation_ is for.
+
+By declaring that a part of your public surface is deprecated, you are telling customers that they should stop using it, and that you may even remove it in a future version.
+Deprecation should be reserved for cases that are truly problematic, not just annoying.
+For instance, if the guarantees provided by a specific method force your entire codebase to use a suboptimal design that makes everything else slower, it may be worth removing the method.
+Another good example is methods that accidentally make it very easy to introduce bugs or security vulnerabilities due to subtleties in their semantics.
+
+For instance, Java's `Thread::checkAccess` method was deprecated in Java 17,
+because it depends on the Java Security Manager, which very few people use in practice and which constrains the evolution of the Java platform,
+as [JEP 411 states](https://openjdk.org/jeps/411).
+
+Here is an example of a less reasonable deprecation from Python:
+```
+>>> from collections import Iterable
+DeprecationWarning: Using or importing the ABCs
+from 'collections'
+instead of from 'collections.abc'
+is deprecated since Python 3.3,
+and in 3.10 it will stop working
+```
+Sure, having classes in the ""wrong"" module is not great, but the cost of maintaining backward compatibility is low.
+Breaking all code that expects the ""Abstract Base Collections"" to be in the ""wrong"" module is likely more trouble than it's worth.
+
+Deprecating in practice means thinking about whether the cost is worth the risk, and if it is, using your language's way of deprecating,
+such as `@Deprecated(...)` in Java or `[Obsolete(...)]` in C#.
+
+### Consuming versions
+
+Using specific versions of your dependencies allows you to have a ""known good"" environment that you can use as a solid base to work.
+You can update dependencies as needed, using version numbers as a hint for what kind of changes to expect.
+
+This does not mean you should 100% trust all dependencies to follow compatibility guidelines such as semantic versioning.
+Even those who try to follow such guidelines can make mistakes, and updating a dependency from 1.3.4 to 1.3.5 could break your code due to such a mistake.
+But at least you know that your code worked with 1.3.4 and you can go back to it if needed.
+The worst-case scenario, which is unfortunately common with old code, is when you cannot build a codebase anymore
+because it does not work with the latest versions of its dependencies and you do not know which versions it expects.
+You then have to spend lots of time figuring out which versions work and do not work, and writing them down so future you does not have to do it all over again.
+
+In practice, in order to manage dependencies, software engineers use package managers, such as Gradle for Java, which manage dependencies given versions:
+```
+testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
+```
+This makes it easy to get the right dependency given its name and version, without having to manually find it online.
+It's also easy to update dependencies; package managers can even tell you whether there is any newer version available.
+You should however be careful of ""wildcard"" versions:
+```
+testImplementation 'org.junit.jupiter:junit-jupiter-api:5.+'
+```
+Not only can such a version cause your code to break because it will silently use a newer version when one is available,
+which could contain some bug that breaks your code, but you will have to spend time figuring out which version you were previously using, since it is not written down.
+
+For big dependencies such as operating systems, one way to easily save the entire environment as one big ""version"" is to use a virtual machine or container.
+Once it is built, you know it works, and you can distribute your software on that virtual machine or container.
+This is particularly useful for software that needs to be exactly preserved for long periods of time, such as scientific artifacts.
+
+
+## Summary
+
+In this lecture, you learned:
+- Evolving legacy code: goals, refactorings, and documentation
+- Dealing with large codebases: learning as you go, improving the code incrementally
+- Quantifying and describing changes: compatibility and versioning
+
+You can now check out the [exercises](exercises/)!
+",CS-305: Software engineering
Proposed solution (click to expand)
++ +- Adding a new class is binary compatible, since no previous version could have referred to it. + It is generally considered to be source compatible, except for the annoying scenario in which someone used wildcard imports (e.g., `import org.example.*`) + for two modules in the same file, and your new class has the same name as another class in another module, at which point the compiler will complain of an ambiguity. +- Making a return type less specific is not backward compatible. + The signature changes, so binary compatibility is already broken, + and calling code must be modified to be able to deal with more kinds of values, so source compatibility is also broken. +- Making a return type more specific is source compatible, since code that dealt with the return type can definitely deal with a method that happens to always return a more specific type. + However, since the signature changes, it is not binary compatible. +- Adding a parameter is neither binary nor source compatible, since the signature changes and code must now be modified to pass an additional argument whenever the function is called. +- Making a parameter type less specific is source compatible, since a function that accepts a general type of parameter can be used by always giving a more specific type. + However, since the signature changes, it is not binary compatible. +- Making a parameter type more specific is not backward compatible. + The signature changes, so binary compatibility is already broken, + and calling code must be modified to always pass a more specific type for arguments, so source compatibility is also broken. +
+