OpenLLM-France/wikimedia huggingface dataset:
# Muggles' Guide to Harry Potter/Characters/Marlene McKinnon
## Overview

Marlene McKinnon is a former member of the Order of the Phoenix who was killed along with her family.

## Role in the Books
### Philosopher's Stone

In their first meeting, Hagrid mentions to Harry that Voldemort killed some of the best wizards of the age such as the McKinnons, along with the Bones and the Prewetts.

### Goblet of Fire

As part of his attempt to plea-bargain his way out of Azkaban, Igor Karkaroff accuses Travers of killing the McKinnons.

### Order of the Phoenix

At the celebratory party at Grimmauld Place for Ron and Hermione's appointment as Prefects, Alastor Moody shows Harry a photograph of the original Order of the Phoenix. Marlene McKinnon is in that photo, and Moody says that she and her family had been killed by Death Eaters.

### Deathly Hallows

McKinnons are mentioned in a letter written to Sirius by Lily. In the letter Lily mentions that she cried all evening after hearing of McKinnons´ murder.

## Relationships with Other Characters

She and her family seems to have friendly relationship with some of the Order members. Lily mentioned in the letter to Sirius Peter was sad probably because of the death of McKinnons and that she (Lily) cried all evening when she got the news.

## Questions

Study questions are meant to be left for each student to answer; please don't answer them here.
# Muggles' Guide to Harry Potter/Characters/Marcus Belby
## Overview

Marcus Belby, a student in Ravenclaw house at Hogwarts of approximately Harry's age, is the nephew of Damocles Belby, the wizard who invented Wolfsbane Potion.

## Role in the Books
### Half-Blood Prince

Horace Slughorn invites Marcus, along with a number of other people that he judges to be the potential movers and shakers of the Wizarding world, to lunch with him on the Hogwarts Express. When he learns that Marcus is estranged from his famous uncle, Slughorn effectively dismisses him.

### Deathly Hallows
## Analysis

Belby is brought into the story, as far as we can see, only to cast a light on Slughorn and some specifics of his social climbing. We see that Slughorn is willing to cultivate Belby as long as he has hopes of making a connection with Belby's still living famous uncle. As Damocles is estranged from Marcus' side of the Belby family, he does not represent a useful connection. We suspect that this particular shallowness in Slughorn's character is one of the things that Harry dislikes, and one of the reasons Harry avoids the Slug Club.

## Questions

Study questions are meant to be left for each student to answer; please don't answer them here.
# Introduction to Information Technology/Introduction

What is Information Technology? Well that's simple. Information Technology (IT) encompass the study and application of computers and any form of telecommunications that store, retrieve and send information. IT includes a combination of hardware and software used together to perform the essential functions people need and use everyday. Most IT professionals will work with an organization to focus on and meet their needs technologically by understanding what they need, showing them options on what current technology is available to do their needed tasks, then implementing the technology into their current setup, or creating a whole new set up.
# Pinyin/Be hampered

See also
# Pinyin/Base on

Search Pinyin base
# Pinyin/Be abandoned

See also
# Pinyin/Be easy

See also
# Pinyin/Be injured

See also
# Pinyin/Base

Search Pinyin base
# Pinyin/Be

See also
# Modern C++: The Good Parts

Many tutorials for C++ are targeted to C++ as it was standardized in 2003 (C++03) or earlier. Recent progress has produced C++11 and now C++14, and these newer versions have improved the level of simplicity and readability that is feasible for beginners. Many of these improvements supplant older features as the "best way" to solve problems. This book will present problems of increasing complexity, and not explain any given feature until it becomes appropriate for a problem. (See the talk page for a detailed discussion of this.)
This book assumes the reader has access to an instructor (or savvy friend), and takes advantage of this for some of the assignments.

## Outline

* The Basics
** Getting a compiler
** Hello, world!
** Anatomy of a global greeting
** The world's response
** Number crunching
* Control Flow
** Now it gets interesting.
** Switching things up
** Getting loopy
** At last, functions
** Let's take a breather.
** Those pesky exceptions
** Overloaded but not overburdened
# Modern C++: The Good Parts/Getting a compiler

C++ is a compiled language, meaning that those who use it commonly use a compiler to convert C++ source code into something more machine-friendly, which is then executed. You will need a compiler to complete the exercises in this book, but fear not! Compilers are freely available and reasonably easy to set up. This page will attempt to help you decide which one(s) to install.
If you expect to learn GUI development with Qt later, you should install Qt Creator, and make sure to check the box for the latest MinGW. (Note: If you're one of my students, get Qt Creator.)
Visual Studio Express for Windows Desktop is a good free option which requires essentially zero setup, other than a very long installation. If you have money to spend, some other version of Visual Studio can serve you better, but you can make that decision later.
Clang can be a better option, except that its setup can be very involved, especially if you happen to want the latest version for Windows (in which case read this). Clang is well-known for very useful error messages.
The GNU Compiler Collection (GCC) is another good option. On Windows, MinGW is little more than the compiler while Cygwin is like some Linux for your Windows. If you don't understand that last part, just go with MinGW.
If you don't trust my short list, see the significantly longer one from the originator of C++, Bjarne Stroustrup.
Once you have a compiler installed, see the next page to make sure it's in working order.
# Models and Theories in Human-Computer Interaction/Working hard (or hardly working) in a collective wiki effort
## Working hard (or hardly working) in a collective wiki effort (Cindy Marinak)

WikiBook's support of distributed users and ability to externalize representation (Carroll, 2003) effectively provides "transparency" of a collaborative computer-mediated interface in enabling human(s)-human(s) interaction. However, motivation to contribute may be deterred based on a set of factors related to Karau and Williams’ theory of collective effort.
The theory of collective effort highlights two motivational problems, social loafing and social pressure. According to HCI Models, Theories, and Frameworks, social loafing is a phenomenon describing the degradation of individual productivity and contributions when working with a group. Social loafing may be reduced when contributions are identifiable. The downside of knowing the contributor's identity is the potential for censorship and volume of shared data based on social pressure. (Carroll, 2003) How might the individual be judged by the group?
While social loafing and social pressure are potential deterrents, I believe knowing an individual's contributions provides accountability; ideally, it promotes more balanced contributions from individual group members, particularly in environments where face-to-face context is not possible due to a team's composition. For instance, many companies are comprised of offshore teams and/or remote employees. The distributed workforce (often across multiple time zones) requires additional ways of coordinating efforts and communicating shared ideas and processes. While these team members may have a window of time each day to exchange ideas via applications like WebEx or personal communicator, additional tools are necessary to support a productive environment.
When there is positive group synergy, team goals are clearly conveyed, and individuals are encouraged to contribute, wikis may provide a transparent and collaborative central location for communicating ideas and processes.
Works Cited Carroll, J. M. (2003). HCI Models, Theories, and Frameworks. San Francisco: Morgan Kaufmann Publishers.
# Modern C++: The Good Parts/Anatomy of a global greeting

Let's examine our program from last time in more detail.

## Code & explanation

These includes are required by the standard, so anyone who wants to offer a proper C++ compiler must provide them. Several includes are required that way, and the set of them is called the standard library.
* <iostream> allows us to use std::cout and std::cin. All of our programs will include it, because they're all console programs.
* <string> is needed anytime you want a string (a value that represents text), which will also be all of our programs.
As mentioned before, int main is required for all C++ programs. Ignore the parentheses and curly brackets for now; just know that they're necessary.
std::cout and std::cin are for console output and input, respectively. std is the namespace, which basically means who gave them to us, and this one is the standard namespace - i.e., these are from the standard library. The "c" just means C++ inherited them from its "parent" language, C.
The "\n" at the end of the string is a line break or newline; it causes further text to be printed on an additional line.

## Vocabulary
### standard library

    several useful pieces of code required by the C++ standard, shipped with all C++ compilers, all under the namespace std.

### string

    a value that represents text.

### namespace

    a directory of names, or where to look for something by name.

### newline

    a character which separates two lines of text. Also called a line break. Syntax: \n
# Modern C++: The Good Parts/At last, functions

Functions are so important to programming that teaching control structures has been rather tedious without them, so with great relief let's see how to make our own.

## Explanation

Woohoo, the code just got much easier to read, once you understand functions.
As the comments kind of explain, each function has a return type before its name. A function's return type will be the type of any calls to that function. A function call is an expression which causes a function to be run, such as std::stof(temp). When the control flows over a return statement, the containing function exits. The function's caller then receives the return value as the value of the function call and continues from that point.
return can stand in for break in a switch. The point is that control doesn't "fall through" from one case to another. C++ does allow that to happen, but it can be very confusing and it's rarely useful.
By now, you've probably noticed that main has a return type of int. It's the only non-void function that you don't need to return from; by default, it returns 0 when control reaches the bottom. 0 indicates that the program was successful, or ran without problems; any other value tells whoever ran the program that something went wrong. These values are called "exit codes", but you won't need to specify one anytime soon.
Functions also have parameters, the variables declared between their parentheses. Any function call must provide a value for each of the function's parameters; these values are called arguments.
Finally, a function must appear in the source before any call to it. However, C++ offers an important loophole to this that we'll cover later.

## Exercises

under construction

## Vocabulary
### return type

    the type of value that any call to a specific function will be resolved to.

### function call

    an expression which causes a function to be run.

### caller

    the function which contains a specific function call.

### return value

    the value that a specific function call will be resolved to.

### void

    a return type meaning that nothing is returned.

### parameter

    a variable in a function which is assigned by each call to that function.

### argument

    the value of a parameter for a specific call to a function.
# Modern C++: The Good Parts/Getting loopy

For this chapter, we have a calculator willing to perform more calculations than you are willing to input.

## Explanation

This program will run until your terminal stops running it (because you press Ctrl+C, or click the X). That's because the while loop, every time control reaches its bottom, jumps back up to the top - if its condition is still true, which it always will be in this case.
If we weren't in a context where the user could easily halt the loop, the while(true) would be a very bad idea. Instead of true, you can put any Boolean expression (like a == b) or bool variable between the parentheses.
Suppose we wanted to allow up to ten iterations (passes through the loop) instead of an unlimited number. We could do this:
And that would work just fine.
i++ is the same thing as i = i + 1, and results in i being one greater than it was. It's also the same as i += 1.
But C++ provides a prettier way to write that, the for loop:
For the first iteration, i will have the value 0. For the last iteration, it will have the value 9. It will never (usefully) have the value 10 because, just like with our equivalent while loop above:
* the iteration runs;
* then i is incremented;
* then i < 10 is checked, and if it's false the loop is exited.
Nonetheless, the loop does run 10 times.

## Exercises

under construction

## Vocabulary
### while loop

    continues looping until its condition is false.

### iteration

    one pass through a loop. Also, the action of looping or "iterating".

### for loop

    more suited to counting than a while loop is.
# Modern C++: The Good Parts/Let's take a breather.

Up to now, we've only covered what has been used in our programs, but that's leaving some irritating gaps. This chapter is to fill those gaps.

## Loops
### do..while

There's another kind of loop we haven't mentioned:
As you might have guessed, this is very similar to a while loop. A do..while loop reverses the two things done by an ordinary while loop, which are:
* check condition, exit if false;
* run loop body.
A while loop repeats those two steps over and over until the condition tests false. A do..while loop, in contrast, repeats them like this:
* run loop body;
* check condition, exit if false.
The effect is that a do..while loop guarantees one iteration, whereas a while loop might not run its body at all. This is useful, in particular, when you're reading data from somewhere else, like a file, and whether you should continue depends on what you've read.

### break

Loops can be a whole lot more complicated than "start..repeat until X..exit". That complexity can be a very bad thing, but it can also be very useful.
For example, completing a loop is not the only way out. Remember the break statements used in switches? Well, they can also exit loops. If you have a loop in a loop in a loop (another example of nasty complexity), break will only exit the smallest one it's in. If you have a switch in a loop, break inside the switch will only exit the switch.
If you like, imagine that the language starts from the break statement, searches backward through the code, and exits the first loop or switch it finds.
Here's an example of break in a loop:
# Modern C++: The Good Parts/Now it gets interesting.

Up to now all of our programs have been very straightforward: Start at the top and read each line once until you get to the bottom. That changes now, because that's not really a very useful way to write a program. Useful programs usually repeat some things, or decide to not do some. This chapter covers how to select a course of action on the fly.

## Explanation

bool is short for Boolean, which means yes or no, true or false. In this case the bool variable "canDecide" is initialized to the value true. Basically, the program assumes it "canDecide" which number is greater, until it sees evidence to the contrary. Overwriting bools in this way can be very useful.
== is the equality operator; it determines whether two values are equal, and returns true or false. Note: It does not change the value of anything.
Anything that looks like if(...){...} is an if statement. a == b is an expression which evaluates to a bool. An expression is some code which can be resolved to a value. The curly brackets just after if(a == b) contain code which will run if a equals b.
else if means "Otherwise, if..." and is only tested if the condition (the bool) is false for the first if statement. else by itself doesn't test any condition, but only runs if none of the if statements in its chain have been run.
When some logic is selected for execution in this way, "control" is said to "flow" into the logic. So if statements are considered control flow statements or control structures, a set which contains some other constructs to be introduced later.

## Exercises

* Write a calculator, asking the user for two floats and an operator and then printing the result.

## Vocabulary
### bool

    one of two possible values, true or false. Also called a condition.

### expression

    some code which can be resolved to a value.

### if statement

    runs if its condition is true. Syntax: if(condition){ }

### control flow

    which code runs, and in what order.

### control structure

    a statement which modifies control flow. Also called a control flow statement.
# Models and Theories in Human-Computer Interaction/dCog : A foundation for interface evaluation ?

Distributed Cognition provides a systemic perspective to look into micro interactions. The ability of dCog to address both physical and social aspects provides a power to gain insights into micro interactions.
Designer of a complex system faces challenges in evaluating and tracing interfaces & interactions. Modelling those paths is essential for complex system designer to evaluate, manage and maintain interfaces. Wright Fields and Harrison, proposed a way to model interaction using dCog (Reference 1). They state that "DC Research identifies resources for action as central to the interaction between people and technologies, but it stops short of providing a definition of such resources at a level that could be used to analyze interaction."
Wright Fields and Harrison, proposes an information model that comprises of two major structure. Information Structures and Interaction Strategies. Information structure focuses on abstract information and representational models. Interaction strategies define various ways with which users can interact with the information. In this paper the authors has used this model to create different interfaces which results in varying performances.
This foundation provides a robust way to model and evaluate design artifacts, for a give set of interactions. This model can be aptly named to be skeleton of an interaction model. The skeleton provides more advanced works to be conducted.
For instance, such a model will be helpful in designing, evaluating adaptive interfaces. In another example applying dCog model in pervasive computing environments will enable designers to delivery Context sensitive and appropriate experiences.
Reference 1: ANALYSING HUMAN-COMPUTER INTERACTION AS DISTRIBUTED COGNITION: THE RESOURCES MODEL Peter Wright, Bob Fields, Michael Harrison http://e-centre.mdx.ac.uk/staffpages/bobf/papers/res-hci.pdf
# Modern C++: The Good Parts/Hello, world!

What are we waiting for? Here's your first C++ program. Save it in your editor (such as Qt Creator or Visual Studio), compile or build it, and run the executable. This will prove whether your compiler is working, which will be rather important for later exercises.

## Explanation

Those first two lines tell the compiler what includes (pre-existing code) we need. int main is required for any C++ program, and the logic inside the curly brackets is everything that will be done. The particular way that C++ requires us to arrange code is called its syntax.
In this case, we send the text "Hello, world!" to the console.
These first two chapters have been kept short to allow for complications with setting up your compiler, but following chapters will pick up the pace.

## Vocabulary
### includes

    files containing code that we can use in our own program.

### syntax

    the specific rules of a language, or basically what the language looks like.
# Perl Programming/Keywords/require
## The require keyword

The require keyword demands a Perl VERSION, some semantics specified by EXPRESSION or which is in $_, if EXPRESSION is missing. VERSION may be either a numeric argument like as 5.006 that will be compared to $], or a literal of the form v5.6.1 that will be compared to $^V (= $PERL_VERSION). The literal form should be avoided, as it leads to misleading error messages in early Perl versions. If VERSION is larger than the version of the Perl interpreter, an exception is raised.
Without these parameters, require demands a file to be included, if it has not already been included before. The file will not be included twice under the same specified name. The included file must return true at the end, so, it is custom to end such files with a 1.
If the EXPRESSION is a bareword, require assumes a .pm extension, replacing all :: with / in the filename so that standard modules load easily.
Before searching for a file with the .pm extension, require searches first for a file with .pmc extension, loading it instead of the .pm file, if found.

### See also

* use
# Perl Programming/Keywords/return
## The return keyword

The return operator returns from an do FILE, eval, or subroutine with the value in EXPRESSION. EXPRESSION can be evaluated in list, scalar, or void context, depending on the use of the return values. The context may vary from one execution to the other. Without an EXPRESSION, it returns an empty list in list context, undef in scalar context, and nothing at all in void context.
If return is omitted altogether, the value of the last evaluated expression is returned.
Unlike most named operators, return is also exempt from the looks-like-a-function rule. So, return ("foo")."bar" will cause "bar" to be part of the argument to return.
# Perl Programming/Keywords/rmdir
## The rmdir keyword

rmdir removes the directory with the name specified by FILENAME, if the directory is empty. rmdir returns true on success and false otherwise, setting $! (errno). Without FILENAME, contents of $_ are used.

### See also

* rmtree
| chdir | closedir | mkdir | opendir | readdir | rewinddir | rmdir | seekdir | telldir |
# Perl Programming/Keywords/s
## The s keyword

s is the substitution operator.

### See also

* m
* y
# Perl Programming/Keywords/reset
## The reset keyword

The reset command clears variables and resets ?? at the end of a loop. It is generally used in a continue block. The EXPRESSION is understood as a list of single characters, where hyphens are allowed for ranges. It always returns 1.
All arrays and variables beginning with these characters in the current package are reset to their original state. Without the EXPRESSION, the one-time searches in the current package (?pattern?) are reset so that they can match again.
Before searching for a file with the .pm extension, reset searches first for a file with .pmc extension, loading it instead of the .pm file, if found.
Setting EXPRESSION to EXPRESSION is not recommended, as it wipes out the @ARGV and @INC arrays, and the %ENV hash.

### See also

* use
# Perl Programming/Keywords/readlink
## The readline keyword

readlink is a function that returns the value of a symbolic link. If such links are not implemented, it raises an exception. If EXPRESSION is not passed, $_ is used instead. If there is a system error, returns the undef and sets $! (errno).
# Perl Programming/Keywords/readpipe
## The readpipe keyword

readpipe executes EXPRESSION as a system command and returns the collected standard output. If called from scalar context, a string is returned. If called from list context, a list of lines as defined by $/ or $INPUT_RECORD_SEPARATOR is returned. This is the internal implementation of the qx/EXPRESSION/ operator.

### See also

* qx