OpenLLM-France/wikimedia huggingface dataset:
# Aros/Developer/Docs/HIDD/i2c

* Navbar for the Aros wikibook
* Aros User
* Aros User Docs
* Aros User FAQs
* Aros User Applications
* Aros User DOS Shell
* Aros/User/AmigaLegacy
* Aros Dev Docs
* Aros Developer Docs
* Porting Software from AmigaOS/SDL
* For Zune Beginners
* Zune .MUI Classes
* For SDL Beginners
* Aros Developer BuildSystem
* Specific platforms
* Aros x86 Complete System HCL
* Aros x86 Audio/Video Support
* Aros x86 Network Support
* Aros Intel AMD x86 Installing
* Aros Storage Support IDE SATA etc
* Aros Poseidon USB Support
* x86-64 Support
* Motorola 68k Amiga Support
* Linux and FreeBSD Support
* Windows Mingw and MacOSX Support
* Android Support
* Arm Raspberry Pi Support
* PPC Power Architecture
* misc
* Aros Public License

## Introduction

Yes, i2c is there and works. It's rarely used, mostly by graphics drivers to read EDID information from monitor. I2C stack is also used on sam440 target, to read the RTC.

## References

If you want to use I2C with e.g. parallel port, you will need to write a "driver". A driver is an OOP object with superclass CLID_Hidd_I2C. The driver class has to implement two methods only:
how you implement them (which part of parallel port you are going to use), it's up to you. There are no direct examples how to use I2C, but you could look into the source code of drivers, which are using it, like eg. the IntelGMA driver (file intelG45_class.c).
# Aros/Developer/Docs/LLVM

* Navbar for the Aros wikibook
* Aros User
* Aros User Docs
* Aros User FAQs
* Aros User Applications
* Aros User DOS Shell
* Aros/User/AmigaLegacy
* Aros Dev Docs
* Aros Developer Docs
* Porting Software from AmigaOS/SDL
* For Zune Beginners
* Zune .MUI Classes
* For SDL Beginners
* Aros Developer BuildSystem
* Specific platforms
* Aros x86 Complete System HCL
* Aros x86 Audio/Video Support
* Aros x86 Network Support
* Aros Intel AMD x86 Installing
* Aros Storage Support IDE SATA etc
* Aros Poseidon USB Support
* x86-64 Support
* Motorola 68k Amiga Support
* Linux and FreeBSD Support
* Windows Mingw and MacOSX Support
* Android Support
* Arm Raspberry Pi Support
* PPC Power Architecture
* misc
* Aros Public License

## Introduction

Boot partition signature ssuming AROS.boot can only contain one entry. Yes, and what? How can the same partition be bootable for example on > both PPC and i386?
like to see an ELF loader based on architecture-neutral LLVM bitcode. The LLVM Team is working on such a project right now under MacOSX and Linux. Although PPC and i386 cannot boot the same thing due to endianness without patching, ARM and i386 could.
# Aros/Developer/Docs/Libraries/AROSC

* Navbar for the Aros wikibook
* Aros User
* Aros User Docs
* Aros User FAQs
* Aros User Applications
* Aros User DOS Shell
* Aros/User/AmigaLegacy
* Aros Dev Docs
* Aros Developer Docs
* Porting Software from AmigaOS/SDL
* For Zune Beginners
* Zune .MUI Classes
* For SDL Beginners
* Aros Developer BuildSystem
* Specific platforms
* Aros x86 Complete System HCL
* Aros x86 Audio/Video Support
* Aros x86 Network Support
* Aros Intel AMD x86 Installing
* Aros Storage Support IDE SATA etc
* Aros Poseidon USB Support
* x86-64 Support
* Motorola 68k Amiga Support
* Linux and FreeBSD Support
* Windows Mingw and MacOSX Support
* Android Support
* Arm Raspberry Pi Support
* PPC Power Architecture
* misc
* Aros Public License

## Introduction

The arosc library only allows that one task at a time calls a function with the same libbase. AFAIK this does not break any standards. In a later stage a thread implementation will be provided that will to do proper locking around the C functions that need, this should also be usable when you implement your own thread implementation.
Current arosc is not thread-save and the C libs in ABI V1 neither. The best way to get is have a front-end similar to clib2-ts on AROS.
YAM is not using any threading library but its own thread implementation. And even if it would use stuff like pthreads it is the C runtime lib's task to protect its internal stuff from race conditions. No thread framework is able to take this load off the C lib, because this is internal stuff.
For AROS' arosc.library a simple ObtainSemaphore/ReleaseSemaphore pair around all implicit and explicit accesses to the __stdio_files list would be a good start. However, there will very probably be many more locations which require enforced single threading to avoid race conditions.
As an intermediate solution already a static link library can be provided that does the proper locking around the function that need it, e.g. arosc-ts (analog to clib2-ts).
Perhaps you should contact Olaf Barthel and port over his clib2 to AROS. I already asked him and he has no objections against such a port. The more systems use clib2 the more possible bugs will be found. I think clib2 C implementation as a static link library would complement the AROS C shared libraries for the programs that depend on certain clib2 peculiarities.
This may be a bit naive, we may need to consider an OpenLibrary of the AROS C *shared* library for each thread. That eliminates the locking issue, we just need to make the AROS C data area private to each thread.
This may need some headers and linker support, but it should be much easier to implement than a full locking implementation, and would be a lightweight code change. That is not what users want. They want to be able to have one thread do IO with a file opened by another thread.
# Bash Shell Scripting/Intro Exercise

We will look at a few example to get a taste as to what Bash scripting can be used. Do not fret if you do not understand these just yet.

## Hello World

Let's start with a simple "hello world" program:
We can either type this directly at the Bash prompt, or else save this as a file (say, hello_world.sh) and run it by typing bash hello_world.sh or ./hello_world.sh at the Bash prompt. (Later we will see some more sophisticated ways to create and run a Bash script file.) In either case, it will print Hello, world!:
Here we have used the $ symbol to indicate the Bash prompt: after $, the rest of the line shows the command that we typed, and the following line shows the output of the command.

## Check File

Here is a slightly more complex script:
This script tests whether there exists a file named readme.txt in the current directory, and uses an if statement to control, based on that test, which commands are run. It, too, could be typed directly at the prompt — any script can — but in this case that is not likely to be useful.
Both of the above are entirely "within Bash", in that they do not require Bash to run any external programs. (The commands echo, if … then … else … fi, and [[ -e … ]] are all built-in commands, implemented by Bash itself.) But, being a shell-scripting language, a large part of Bash's purpose is to run external programs. The following script demonstrates this ability:
Here diff and cp are two common utility programs that, while not part of Bash, are found on most systems that have Bash. The above script assumes the presence of a default configuration file named config-default.txt, and checks for the presence of a configuration file named config.txt. If config.txt exists, then the script uses the external program diff to produce a "diff" (a report of the differences between, in this case, two files), so that the user can see what non-default configurations are in place. If config.txt does not exist, then the script uses the external program cp ("copy") to copy the default configuration file to config.txt.
As you can see, the external programs are run using the same sort of syntax as the built-in commands; they're both just "commands".
The above version of this script is very "verbose", in that it generates a great deal of output. A more typical script would likely not include the echo commands, since users are unlikely to need this level of information. In that case, we might use the # notation to include comments that are completely ignored by Bash, and do not appear to the user. Such comments are simply informative notes for someone reading the script itself:
But the above is simply for demonstration's sake. In reality, a script this simple does not require any comments at all.
# Bash Shell Scripting/Prerequisites

You will need to have Bash installed on your system. It is recommended that you use a GNU/Linux based distribution like Ubuntu, Manjaro, etc. These have Bash installed by default.
If you are using a Unix-like operating system like FreeBSD or MacOS and Bash shell is not installed as default, you can install Bash from their package manager or use their default shell which have Bash support.
If you are on a Windows 10 or Windows 11 system, you can install Windows Subsystem for Linux. If you are on an older machine and don't have SSH access to a GNU/Linux or Unix system, you will probably find it easiest to make use of this book if you are using something like Cygwin, which has not only Bash but also many other common utilities, than if you are using a Bash port for Windows that includes only Bash. If you have Cygwin, just make sure that the directory containing those utilities — likely something like C:\Cygwin\bin — is listed in your Windows path.
On Android, an app called Termux can be installed.
# Bash Shell Scripting/Pipelines And Substitution

As we have seen, a command's return value, taken strictly, is just a small non-negative integer intended to indicate success or failure. Its real output is what it writes to the standard output stream. By default, text written to the standard output stream is printed to the terminal, but there are a few ways that it can be "captured" and used as the command's true return value.

## Pipelines

When a sequence of commands are linked together in a pipeline, the output of each command is passed as input to the next. This is a very powerful technique, since it lets us combine a number of small utility programs to create something complex.

## Command substitution

Command substitution is a bit like variable expansion, but it runs a command and captures its output, rather than simply retrieving the value of a variable. For example, consider our get_password example above:
There is really no reason that the caller should have to save the password in a variable. If get_password simply printed the password to its standard output, then the caller could use command substitution, and use it directly:
To evaluate "$(get_password)", Bash runs the command get_password in a subshell, capturing its standard output, and replaces $(get_password) with the captured output.
In addition to the notation $(…), an older notation `…` (using backquotes) is also supported, and still quite commonly found. The two notations have the same effect, but the syntax of `…` is more restrictive, and in complex cases it can be trickier to get right.
Command substitution allows nesting; something like a "$(b "$(c)")" is allowed. (It runs the command c, using its output as an argument to b, and using the output of that as an argument to a.)
Command substitutions can actually contain a sequence of commands, rather than just one. As we've seen previously, semicolons can be used instead of newlines to separate commands, and it is common to do this within command substitutions. Each of the semicolon-separated statements runs in sequence in a single subshell and their combined output is captured. Command substitutions can also contain variable assignments and function definitions, but these are useful only within the substitution, and do not persist in the parent shell once the substitution is finished.
# Bash Shell Scripting/Input-Output
## The read built-in

From help read:
read is great for both user inputs and reading standard inputs/piping.
An example of user input:
Or even simpler:
Hello-world level example of stdout operation:
Just be creative. For example, in many ways read can replace whiptail. Here is an example, extracted from Arthur200000's shell script:

## Shell redirection

In shells, redirection is used for file I/O. The most common usage of is to redirect standard streams (stdin, stdout and stderr) to accept input from another program via piping, to save program output as a file, and to suppress program output by redirecting a stream to /dev/null.
# Bash Shell Scripting/Loops

Often we want to run the same sequence of commands, over and over again, with slight differences. For example, suppose that we want to take all files named *.txt and rename them to *.txt.bak ("backup"). We can use file-expansion to get the list of files named *.txt, but how do we use that list? There's no obvious command containing, say, 'foo.txt' 'bar.txt' 'baz.txt', that would perform the three moves we need. What we need is a for loop:
The above takes the variable file, and assigns it in turn to each word in the expansion of *.txt. Each time, it runs the body of the loop. In other words, it is equivalent to the following:
There is nothing special here about filename expansion; we can use the same approach to iterate over any other argument-list, such as the integers 1 through 20 (using brace expansion):
or the positional parameters "$@":
In fact, that specific case is so common that Bash provides the equivalent shorthand for arg ; do, with in "$@" being implied. (But it's probably better to use the explicit form anyway.)
Another kind of loop is the while loop. It is similar to an if statement, except that it loops repeatedly as long as its test-command continues to be successful. For example, suppose that we need to wait until the file wait.txt is deleted. One approach is to "sleep" for a few seconds, then "wake up" and see if it still exists. We can loop repeatedly in this fashion:
Conversely, we can use an until loop to loop until a given command is successful; for example, the reverse of the above might be:
Of course, this is the same as combining while with !, but in some cases it may be more readable.
# C++ Programming/Compiler/Linker/Libraries/Configuring Visual Studio
### Example: Configuring MS Visual C++ to use external libraries

The Boost library is used as example library.
Considering you already have decompressed and have the binary part of the Boost library built. There the steps which have to be performed:

#### Include directory

Set up the include directory. This is the directory that contains the header files (.h/hpp), which describes the library interface:

#### Library directory

Set up the library directory. This is the directory that contains the pre-compiled library files (.lib):

#### Library files

Enter library filenames in additional dependencies for the libraries to use:
Some libraries (such as e.g. Boost) use auto-linking to automate the process of selecting library files for linking, based on which header-files are included. Manual selection of library filenames are not required for such libraries if your compiler supports auto-linking.

#### Dynamic libraries

In case of dynamically loaded (.dll) libraries, one also has to place the DLL-files either in the same folder as the executable, or in the system PATH.

#### Run-time library

The libraries also have to be compiled with the same run-time library as the one used in your project. Many libraries therefore come in different editions, depending on whether they are compiled for single- or multi-threaded runtime and debug or release runtime, as well as whether they contain debug symbols or not.
# C++ Programming/Code/Statements/Functions/Returning Values/Static Return
#### Static returns

When a function returns a variable (or a pointer to one) that is statically located, one must keep in mind that it will be possible to overwrite its content each time a function that uses it is called. If you want to save the return value of this function, you should manually save it elsewhere. Most such static returns use global variables.
Of course, when you save it elsewhere, you should make sure to actually copy the value(s) of this variable to another location. If the return value is a struct, you should make a new struct, then copy over the members of the struct.
One example of such a function is the Standard C Library function localtime.
# C++ Programming/Code/Style Conventions/Comments
## Comments

Comments are portions of the code ignored by the compiler which allow the user to make simple notes in the relevant areas of the source code. Comments come either in block form or as single lines.
* Single-line comments (informally, C++ style), start with // and continue until the end of the line. If the last character in a comment line is a \ the comment will continue in the next line.
* Multi-line comments (informally, C style), start with /* and end with */.
We will now describe how a comment can be added to the source code, but not where, how, and when to comment; we will get into that later.

### C style comments

If you use C style comments, try to use it like this:
Comment single line:
Comment multiple lines:
This allows you to easily uncomment. For example:
Uncomment single line:
Uncomment multiple lines:
... by removing only the start of comment and so activating the next one, you did re-activate the commented code, because if you start a comment this way it will be valid until it finds the close of comment */.

### C++ style comments

Examples:
or
The backslash is a continuation character and will continue the comment to the following line:

#### Using comments to temporarily ignore code

Comments are also sometimes used to enclose code that we temporarily want the compiler to ignore. This can be useful in finding errors in the program. If a program does not give the desired result, it might be possible to track which particular statement contains the error by commenting out code.

#### Example with C style comments

or

#### C and C++ style

Combining multi-line comments (/* */) with c++ comments (//) to comment out multiple lines of code:
Commenting out the code:
uncommenting the code chunk
This works because a //* is still a c++ comment. And //*/ acts as a c++ comment and a multi-line comment terminator. However this doesn't work if there are any multi-line comments are used for function descriptions.

#### Note on doing it with preprocessor statements

Another way (considered bad practice) is to selectively enable disable sections of code:
this is considered a bad practice because the code often becomes illegible when several #if's are mixed, if you use them don't forget to add a comment at the #endif saying what #if it correspond
you can prevent illegibility by using inline functions (often considered better than macros for legibility with no performance cost) containing only 2 sections in #if #else #endif
and call
in the program
# Blended Learning in K-12/Characteristics of Blended Learning

What are the main characteristics of Blended Learning? What makes blended learning unique, different, special?
The term “Blended Learning”, while popular, has been subjected to criticism, mostly because the definition lacks specificity. (See section 1.1 "What is Blended Learning?")The term applies to diverse situations, including professional development in the business world, and technology integration in the K-12 and university settings, and describes a range of instructional practices. Indeed, one critical article has suggested that it is the very focus on instructional practices that is problematical, and that blended learning should instead focus on content from the learner’s, rather than the instructor’s, perspective. (Oliver and Trigwell, 2005) Although criticizing the terminology appears to be merely a discussion over semantics, the lack of specificity raises an interesting question: What are the characteristics of blended learning? A number of sources summarize the following characteristics as being unique to the blended learning environment.
Taking each of these point for point, we may attempt to characterize blended learning by examining its appearance point for point. In other words, by describing these blends as they should appear in a “real” context, we can begin to understand blended learning not as a textbook definition, but as a concept for learning and instruction in the Twenty-first Century.
# Blended Learning in K-12/Blending online and face to face instructors and learners

Blending online and face to face instructors and learners
As stated in the introduction to this chapter, one of the criticisms of Blended Learning is that the definition lacks specificity. (Oliver and Trigwell, 2005) As a result, many of the characteristics of Blended learning look so similar to one another that it is impossible to tell them apart. The characteristics seem to have different terms that describe the same set of criteria. Such is the case for the blending of online and face to face instructors and learners.
After several rounds of discussion, the contributors of this chapter were unable to elucidate the difference between "Blending online and face to face instructors and learners" from "Blending synchronus and asynchronus learning" and "Online and offline Learning."
The only possible difference that we discussed is that in a Blended Learning environment, the line between instructor and learner might be blurred, so that the instructor is not just the person disseminating knowledge, but rather a member of the learning community, who contributes to the construction of knowledge, and takes away from the course re-imagined understandings of the content. In other words, as one Instructor who utilizes blended learning put it, the teacher should be "the guide on the side, instead of the sage on the stage." (Scagnoli, 2005)
# Blended Learning in K-12/Introduction
## Introduction

While teachers have always used a variety of teaching methods and media, blended learning includes the recent availability of digital learning technologies and Internet-based tools that facilitate communication, interaction, and collaborative learning. Neither e-learning nor the traditional classroom are ideal for all types of learning. Blended learning offers the opportunity to incorporate the 'best of both worlds' to improve teaching and learning, to take "advantage of the strengths of both learning environments and be more successful in avoiding their weaknesses." (Node, 2003) Evidence from a study conducted by Alfred P. Rovai and Hope M. Jordan "suggest that blended courses produce a stronger sense of community among students than either traditional or fully online courses" (Rovai and Jordan, 2004).
The subheadings in this chapter will provide more information about blended learning, beginning with What is "Blended Learning"?. This section will discuss what prominent authors in the field are saying about what blended learning really is. While most authorities in the field agree on blended learning's usefulness, each author has a slightly different opinion about what makes a class "blended". Quotes will be used from these researchers, explaining their definitions in detail.
Blended learning has taken many forms since it was first created several years ago. As blended learning evolved, its name and meaning also changed. It has been called hybrid learning, mixed mode learning, and several other names. The second subheading in Chapter One, The many names of Blended Learning, will discuss the countless names of blended learning, review each meaning, and look at how it has evolved into the term we know today.
Finally, Chapter One will examine Why is Blended Learning Important?. Research from many educational areas will be used to show the merits of using blended learning instead of just traditional or e-learning environments.