New pages
Jump to navigation
Jump to search
- 10:03, 27 October 2025 Funktionen: Definition, Notation & Beispiele (hist | edit) [2,768 bytes] Bfh-sts (talk | contribs) (Created page with "= Funktionen: Definition, Notation & Beispiele = Diese Seite führt den Funktionsbegriff (Abbildung) formal ein, klärt die Bezeichnungen und zeigt zentrale Beispiele – auch ausserhalb von ℝ. == Definition (Abbildung) == Seien A und B Mengen. Eine Funktion (Abbildung) f : A → B ist eine Vorschrift, die jedem Element x ∈ A genau ein Element f(x) ∈ B zuordnet. Wesentliche Punkte: * Eindeutigkeit: Zu jedem x ∈ A gibt es genau ein Bild f(x). * Totalität: Je...")
- 09:00, 27 October 2025 Endliche Mengen & Einschluss-Ausschluss-Prinzip (hist | edit) [3,358 bytes] Bfh-sts (talk | contribs) (Created page with "= Endliche Mengen und das Einschluss-Ausschluss-Prinzip = Viele praktische Probleme befassen sich mit **endlichen Mengen**, also Mengen mit abzählbarer Anzahl von Elementen. Für solche Mengen spielt das **Zählen** von Elementen und Überschneidungen eine zentrale Rolle. == Endliche und unendliche Mengen == Eine Menge heißt **endlich**, wenn sie genau *m* verschiedene Elemente enthält, wobei *m* eine natürliche Zahl ist. Sonst heißt sie **unendlich**. Beispie...")
- 08:58, 27 October 2025 Geordnete Paare, n-Tupel & kartesische Produkte (hist | edit) [2,998 bytes] Bfh-sts (talk | contribs) (Created page with "= Geordnete Paare, n-Tupel und kartesische Produkte = In der Mengenlehre spielt die **Reihenfolge** der Elemente normalerweise keine Rolle. Doch in vielen Anwendungen – etwa bei Funktionen oder Datenstrukturen – ist sie entscheidend. Dazu dienen **geordnete Paare** und **Tupel**. == Geordnete Paare == Ein **geordnetes Paar** besteht aus zwei Elementen, bei denen die Reihenfolge eine Rolle spielt. Notation: (a, b) Das erste Element ist **a**, das zweite ist *...")
- 08:57, 27 October 2025 Mengensysteme, Potenzmenge & Partitionen (hist | edit) [2,518 bytes] Bfh-sts (talk | contribs) (Created page with "= Mengensysteme, Potenzmenge und Partitionen = Neben einzelnen Mengen betrachtet man oft **Systeme von Mengen** – also Mengen, deren Elemente wiederum Mengen sind. Dazu gehören wichtige Begriffe wie **Potenzmenge** und **Partition**. == Mengensystem == Eine **Menge von Mengen** heißt ein **Mengensystem**. Beispiel: S = { {1, 2}, {3, 4}, {5} } Jedes Element von S ist selbst eine Menge. == Potenzmenge == Die **Potenzmenge** einer Menge S ist die Menge aller **T...")
- 08:57, 27 October 2025 Mengenalgebra & Dualität: Gesetze und de Morgan (hist | edit) [3,525 bytes] Bfh-sts (talk | contribs) (Created page with "= Mengenalgebra und Dualität = Die in der Mengenlehre definierten Operationen (Vereinigung, Durchschnitt, Komplement, Differenz) folgen bestimmten **algebraischen Gesetzen**. Diese Gesetze erlauben es, Ausdrücke zu vereinfachen oder zu beweisen, dass zwei Mengenoperationen äquivalent sind. == Grundlegende Gesetze der Mengenalgebra == Für beliebige Mengen A, B, C und die Universalmenge U gelten folgende Gesetze: === 1. Idempotenz === A ∪ A = A A ∩ A = A D...")
- 08:56, 27 October 2025 Vereinigung, Durchschnitt, Differenz und Komplement (inkl. Disjunktheit) (hist | edit) [3,026 bytes] Bfh-sts (talk | contribs) (Created page with "= Vereinigung, Durchschnitt, Differenz und Komplement = In der Mengenlehre werden neue Mengen oft durch **Operationen** auf bestehenden Mengen gebildet. Die wichtigsten sind **Vereinigung**, **Durchschnitt**, **Komplement** und **Differenz**. == Vereinigung == Die **Vereinigung** zweier Mengen A und B, geschrieben **A ∪ B**, ist die Menge aller Elemente, die in **A** oder in **B** enthalten sind (oder in beiden). Formale Definition: A ∪ B := {x : x ∈ A ∨ x...")
- 08:48, 27 October 2025 Teilmengen und Gleichheit von Mengen (hist | edit) [2,638 bytes] Bfh-sts (talk | contribs) (Created page with "= Teilmengen und Gleichheit von Mengen = Neben der Zugehörigkeit von Elementen zu Mengen spielt auch die Beziehung zwischen Mengen selbst eine zentrale Rolle. Dazu gehört insbesondere das Konzept der **Teilmengen**. == Definition: Teilmenge == Eine Menge **A** heißt **Teilmengen** von **B**, wenn jedes Element von **A** auch ein Element von **B** ist. Notation: A ⊆ B ⇔ ∀x (x ∈ A ⇒ x ∈ B) Wenn A keine Teilmenge von B ist, schreibt man: A ⊈ B Falls...")
- 08:47, 27 October 2025 Mengen und Elemente: Mitgliedschaft, Extensionalität, Definitionen (hist | edit) [2,846 bytes] Bfh-sts (talk | contribs) (Created page with "= Mengen und Elemente = Die Grundidee der Mengenlehre besteht darin, Objekte – genannt **Elemente** – zu einer **Menge** zusammenzufassen. Diese Elemente können Zahlen, Buchstaben, Personen oder sogar andere Mengen sein. == Elemente und Zugehörigkeit == Die Zugehörigkeit eines Elements zu einer Menge wird mit dem Symbol **∈** ausgedrückt. Beispiele: * 3 ∈ {1, 2, 3, 4, 5} * a ∈ {a, b, c} * 6 ∉ {1, 2, 3, 4, 5} Die Zugehörigkeit ist immer eindeutig:...")
- 08:45, 27 October 2025 Mengenlehre: Überblick & Notation (hist | edit) [3,453 bytes] Bfh-sts (talk | contribs) (Created page with "= Mengenlehre: Überblick & Bedeutung = Die Mengenlehre ist ein grundlegendes Teilgebiet der Mathematik, das von **Georg Cantor (1845–1918)** im 19. Jahrhundert entwickelt wurde. Sie bildet das Fundament nahezu aller modernen mathematischen Disziplinen. Jede mathematische Struktur – von Zahlen über Funktionen bis zu geometrischen Objekten – kann in der Sprache der Mengenlehre formuliert werden. == Ursprung und Idee == Cantor definierte den Begriff der Menge f...")
- 14:57, 20 October 2025 Exercises - 02 Kontrollaufgaben (hist | edit) [4,754 bytes] Bfh-sts (talk | contribs) (Created page with "= Kontrollaufgaben Aussagenlogik Teil 2 = ''Achtung: detaillierte Lösungswege mit Zwischenresultaten werden erwartet. Ohne klar ersichtlichen Lösungsweg bzw. Begründung gibt es keine Punkte.'' == Aufgabe 1 == Max wird mit hohem Fieber und ausgeprägtem Gliederschmerzen in das Spital eingeliefert. Dr. House diskutiert die Diagnose mit einer Kollegin. * Dr. House: „Wenn der Patient Fieber hat, handelt es sich um Grippe oder Erkältung.” * Cameron: „Wenn er kein...")
- 14:57, 20 October 2025 Exercises - 01 Kontrollaufgaben (hist | edit) [2,314 bytes] Bfh-sts (talk | contribs) (Created page with "= Kontrollaufgaben = == Aufgabe 1 == Wenden Sie in den folgenden logischen Ausdrücken die Verneinung auf die Einzelaussagen an: (a) <syntaxhighlight lang='text' inline>¬(¬A ᐯ B)</syntaxhighlight> (b) <syntaxhighlight lang='text' inline>¬(A ⇒ (B ⇒ C))</syntaxhighlight> === Aufgabe 1 - Lösung === a) <syntaxhighlight lang='text'> ¬(¬A ᐯ B) ≡ A ᐱ ¬B (7,10b) </syntaxhighlight> b) <syntaxhighlight lang='text'> (A => (B => C)) ≡ ¬(¬A ᐯ (B => C))...")
- 14:49, 20 October 2025 Hands-on: Debugger Exercise for Register Parts (AX/BX/CX) (hist | edit) [2,905 bytes] Bfh-sts (talk | contribs) (Created page with "= Hands-on: Debugger Exercise for Register Parts (AX, BX, CX) = This exercise helps you understand how register hierarchies and partial register operations work in x86-64 assembly. It focuses on how smaller register portions (8-bit and 16-bit) affect and reflect values in their parent registers. == Background == <syntaxhighlight lang='text'> x86-64 registers are divided into accessible parts: | Register (64-bit) | 32-bit | 16-bit | 8-bit High | 8-bit Low | |----------...")
- 14:48, 20 October 2025 Linux x86-64 Syscalls: syscall, Registers, sys write, sys exit (hist | edit) [3,547 bytes] Bfh-sts (talk | contribs) (Created page with "= Linux x86-64 Syscalls (syscall, Registers, sys_write, sys_exit) = System calls (syscalls) allow a program to interact directly with the operating system. They provide controlled access to privileged functions such as printing to the screen, reading files, or terminating the program. == What Is a Syscall? == In user mode, a program cannot directly access hardware or kernel resources. To perform privileged operations, it must **request** the kernel to do so on its b...")
- 14:48, 20 October 2025 Strings in Assembly: Buffers, Length with $ and equ, Concatenation (hist | edit) [3,072 bytes] Bfh-sts (talk | contribs) (Created page with "= Strings in Assembly (Buffers, Length with $, equ, Concatenation) = Strings in assembly language are simply sequences of bytes in memory. Each byte may represent a character depending on the encoding (commonly ASCII or UTF-8). == What Is a String in Assembly? == A string is not a special data type — it is an array of bytes. The assembler does not automatically track the string’s length or add an end marker. Example: SECTION .data Msg: db "Eat at Joe’s!", 10...")
- 14:48, 20 October 2025 Data Definition Directives: db, dw, dd, dq, equ (hist | edit) [2,210 bytes] Bfh-sts (talk | contribs) (Created page with "= Data Definition Directives (db, dw, dd, dq, equ) = Assembly language provides directives to define data in memory. These specify how many bytes are allocated and what values they hold. == Overview == Data definition directives do not generate executable code — they reserve and optionally initialize memory. They are primarily used in the **.data** and **.bss** sections. == Common Directives == <syntaxhighlight lang='text'> | Directive | Meaning | Size...")
- 14:48, 20 October 2025 Program Structure: .data, .bss, .text, global start (hist | edit) [2,645 bytes] Bfh-sts (talk | contribs) (Created page with "= Program Structure (.data, .bss, .text, global _start) = Assembly programs are organized into well-defined sections that separate code and data. Understanding this structure is crucial for writing, linking, and debugging NASM programs. == Overview == A typical x86-64 assembly program for GNU/Linux contains: * A **comment block** describing metadata * A **.data** section for initialized data * A **.bss** section for uninitialized data * A **.text** section for executabl...")
- 14:47, 20 October 2025 Multiplication and Division (mul, imul, div, idiv) (hist | edit) [3,097 bytes] Bfh-sts (talk | contribs) (Created page with "= Multiplication and Division (mul, imul, div, idiv) = This page explains how integer multiplication and division work in x86-64 assembly. It covers unsigned and signed arithmetic, implicit operands, and register usage. == Multiplication instructions == There are two main multiplication instructions: * **mul** — for unsigned multiplication * **imul** — for signed multiplication Syntax examples: mul rbx imul rbx Both multiply the accumulator register (a-regist...")
- 14:47, 20 October 2025 Sign Extension and Negation (movsx, neg) (hist | edit) [2,132 bytes] Bfh-sts (talk | contribs) (Created page with "= Sign Extension and Negation (movsx, neg) = This page explains how to handle signed numbers of different sizes and how to change their sign in x86-64 assembly. == Copying signed numbers == When using mov to copy signed numbers, the sign bit is not automatically extended to the larger register size. This can lead to incorrect values when moving smaller signed values into larger registers. Example: mov ax, -42 mov bx, ax ; bx = -42 (ok, same size) mov ecx, bx...")
- 14:47, 20 October 2025 Signed Integers and Flags (Two’s Complement) (hist | edit) [2,009 bytes] Bfh-sts (talk | contribs) (Created page with "= Signed Integers and Flags (Two’s Complement) = This page explains how signed integers are represented in x86 architecture using two’s complement and how arithmetic instructions affect CPU flags. == Unsigned vs signed integers == Unsigned integers represent only positive values. Signed integers represent both positive and negative values using two’s complement. Example with 8 bits: * 00000000₂ = 0 * 00000001₂ = +1 * 01111111₂ = +127 * 11111111₂ = −1...")
- 14:47, 20 October 2025 Arithmetic: add, sub, inc, dec (hist | edit) [1,996 bytes] Bfh-sts (talk | contribs) (Created page with "= Arithmetic: add, sub, inc, dec = This page explains basic arithmetic instructions in x86-64 assembly language, including addition, subtraction, increment, and decrement. == Overview == Arithmetic instructions modify register or memory contents. Most of them follow this general pattern: instruction destination, source The result is stored in the destination operand. == Addition (add) == Adds the source value to the destination and stores the result in the destinat...")
- 14:46, 20 October 2025 Labels and Entry Point ( start) (hist | edit) [1,932 bytes] Bfh-sts (talk | contribs) (Created page with "= Labels and Entry Point (_start) = This page explains how labels work in assembly programming and how the program’s entry point is defined. == What are labels == A label is a symbolic name for a memory address. It marks a location in code or data that can be referenced later. Syntax: LabelName: Example: SECTION .data EatMsg: db "Eat at Joe’s" SECTION .text mov rcx, EatMsg ; rcx ← address of the string mov rdx, [EatMsg] ; rdx ← first 8 bytes of the...")
- 14:46, 20 October 2025 Memory Operands in Other Instructions (add, etc.) (hist | edit) [1,996 bytes] Bfh-sts (talk | contribs) (Created page with "= Arithmetic: add, sub, inc, dec = This page explains basic arithmetic instructions in x86-64 assembly language, including addition, subtraction, increment, and decrement. == Overview == Arithmetic instructions modify register or memory contents. Most of them follow this general pattern: instruction destination, source The result is stored in the destination operand. == Addition (add) == Adds the source value to the destination and stores the result in the destinat...")
- 14:46, 20 October 2025 Addressing Modes: Direct, Indirect, Base+Index, Offsets (hist | edit) [2,437 bytes] Bfh-sts (talk | contribs) (Created page with "= Addressing Modes: Direct, Indirect, Base+Index, Offsets = This page explains how different addressing modes work in x86-64 assembly and how they apply beyond the mov instruction. == Overview == Addressing modes define how operands are interpreted by the CPU: * **Immediate** – The value is part of the instruction itself. * **Register** – The operand is stored in a CPU register. * **Memory** – The operand is located in RAM, referenced by an address. Understanding...")
- 14:46, 20 October 2025 mov Instruction: Registers, Immediates, Memory (hist | edit) [2,664 bytes] Bfh-sts (talk | contribs) (Created page with "= mov Instruction: Registers, Immediates, Memory = This page introduces the mov instruction — one of the most fundamental instructions in assembly — and explains the different addressing modes used with it. == The mov instruction == The mov instruction copies (moves) data from one location to another. Syntax: mov destination, source It can copy data: * From one register to another. * From an immediate (constant) value to a register. * From memory to a register (l...")
- 14:46, 20 October 2025 Assembly Programming: Overview & Conventions (hist | edit) [1,919 bytes] Bfh-sts (talk | contribs) (Created page with "= Assembly Programming: Overview & Conventions = This page introduces x86-64 assembly programming, the syntax conventions used in this course, and the tools involved. == Introduction == Assembly language (ASM) is a low-level programming language that provides direct access to the CPU’s instruction set. Unlike high-level languages, assembly operates on registers, memory addresses, and immediate values. In this course, we use NASM (Netwide Assembler) on GNU/Linux wit...")
- 14:45, 20 October 2025 Assembly Playfield: Build, Run & Debug (NASM, LD, GDB) (hist | edit) [2,807 bytes] Bfh-sts (talk | contribs) (Created page with "= Assembly Playfield: Build, Run & Debug (NASM, LD, GDB) = This page provides a practical starting point for experimenting with assembly programming under Linux, using NASM for assembling, LD for linking, and GDB for debugging. == The playfield program == To learn assembly, we use a minimal “playfield” — a small skeleton program that runs correctly but does nothing by default. It provides a clean structure that you can modify freely. Basic structure of `playfie...")
- 14:45, 20 October 2025 Historical Context: Register Growth & Segment Registers (hist | edit) [2,656 bytes] Bfh-sts (talk | contribs) (Created page with "= Historical Context: Register Growth & Segment Registers = This page explains how CPU register design evolved over time and how early architectural choices still influence modern processors. == Register growth over time == The number and width of registers in CPUs have increased dramatically. In the early 1980s, accessing main memory was nearly as fast as using registers, so CPUs could work efficiently with only a few of them. * **1970s:** Typical CPUs had 3–8 gen...")
- 14:44, 20 October 2025 Control Flow: CMP, Jumps, Calls & Syscalls (hist | edit) [3,170 bytes] Bfh-sts (talk | contribs) (Created page with "= Control Flow: CMP, Jumps, Calls & Syscalls = This page explains how the CPU executes instructions conditionally, how it branches to other code locations, and how it calls functions or system routines. == Why control flow is needed == So far, we’ve seen how to move data and perform arithmetic. However, programs must make decisions — for example, execute one piece of code if a value is positive and another if it’s negative. To do this, the CPU must compare val...")
- 14:44, 20 October 2025 Instruction Set Basics: MOV, Arithmetic & Logic (hist | edit) [2,910 bytes] Bfh-sts (talk | contribs) (Created page with "= Instruction Set Basics: MOV, Arithmetic & Logic = This page introduces the concept of the CPU instruction set, the fundamental operations available to all programs, and the most common x86-64 instructions for data movement, arithmetic, and logic. == What is an instruction set == A CPU executes binary-encoded instructions stored in memory. Each instruction defines a specific operation that the processor can perform directly. The complete list of supported instructi...")
- 14:44, 20 October 2025 Flags and Instruction Pointer (RFLAGS & RIP) (hist | edit) [2,584 bytes] Bfh-sts (talk | contribs) (Created page with "= Flags and Instruction Pointer (RFLAGS & RIP) = This page explains two special control elements of the CPU: the flag register, which stores status bits set by operations, and the instruction pointer, which tracks the flow of program execution. == Flags == A flag is a single bit representing a specific condition that resulted from the last CPU operation. Flags are grouped together in a special register: * FLAGS (16-bit) * EFLAGS (32-bit) * RFLAGS (64-bit) Flags are a...")
- 14:44, 20 October 2025 x86-64 Registers: Types, Sizes & Views (RAX/EAX/AX/AH/AL) (hist | edit) [3,294 bytes] Bfh-sts (talk | contribs) (Created page with "= x86-64 Registers: Types, Sizes & Views (RAX/EAX/AX/AH/AL) = This page describes the types of CPU registers, their evolution in the x86 architecture, and how modern 64-bit CPUs view and manage them. == Register overview == Registers are named memory cells inside the CPU. They have no memory addresses but are directly referenced by name. Their names and functions depend on the processor’s instruction set architecture (ISA). On x86 and x86-64 architectures, there...")
- 14:44, 20 October 2025 Programming Model: CPU, ALU, Registers & Instruction Cycle (hist | edit) [2,871 bytes] Bfh-sts (talk | contribs) (Created page with "= Programming Model: CPU, ALU, Registers & Instruction Cycle = This page introduces the structure and operation of a CPU, focusing on the arithmetic logic unit (ALU), registers, and the instruction cycle that drives program execution. == Arithmetic Logic Unit (ALU) == A computer’s name derives from its ability to compute. The Arithmetic Logic Unit (ALU) is the part of the CPU responsible for: * Performing arithmetic operations (addition, subtraction, multiplication,...")
- 14:43, 20 October 2025 Registers (hist | edit) [4,848 bytes] Bfh-sts (talk | contribs) (Created page with "= Understanding x86 and x86-64 Registers = Registers are the CPU’s **fastest storage locations**. They hold temporary values, addresses, and control information used during computation. This page explains the structure and hierarchy of registers on x86 and x86-64 CPUs — including the confusing relationship between AX, EAX, and RAX. == 1. What is a Register? == A **register** is a very small, very fast memory cell inside the CPU. Unlike RAM, registers are direc...")
- 14:43, 20 October 2025 Workflow in Practice: Edit–Assemble–Link–Run–Debug (hist | edit) [2,782 bytes] Bfh-sts (talk | contribs) (Created page with "= Workflow in Practice: Edit–Assemble–Link–Run–Debug = This page summarizes the entire development process for assembly programs, showing how editing, assembling, linking, running, and debugging fit together. == The complete workflow == A typical software development process in low-level programming consists of five main phases: 1. **Editing** – Writing and commenting the source code. 2. **Assembling** – Translating the human-readable source into machine...")
- 14:42, 20 October 2025 Build Automation with make: Rules, Targets & Makefiles (hist | edit) [2,963 bytes] Bfh-sts (talk | contribs) (Created page with "= Build Automation with make: Rules, Targets & Makefiles = This page introduces build automation with the `make` tool, which simplifies and automates compiling and linking assembly or C programs. == Why build automation? == Large programs consist of many files and dependencies. Building each file manually with assembler and linker commands becomes repetitive and error-prone. Build automation tools solve this problem by: * Automating the steps required to build soft...")
- 14:42, 20 October 2025 Build & Debug Basics: Warnings, Errors, gdb Intro (hist | edit) [2,929 bytes] Bfh-sts (talk | contribs) (Created page with "= Build & Debug Basics: Warnings, Errors, gdb Intro = This page explains how to handle warnings and errors during assembly and linking, and introduces the concept of debugging. == Assembling and linking workflow == Typical workflow when writing assembly programs: 1. Edit and comment the source code (e.g. eatsyscall64.asm). 2. Assemble the source to produce an object file (`.o`). 3. Link object files to create an executable. 4. Run and test the executable. Each...")
- 14:42, 20 October 2025 Hands-on Example: eatsyscall64 (NASM + ld) (hist | edit) [2,714 bytes] Bfh-sts (talk | contribs) (Created page with "= Hands-on Example: eatsyscall64 (NASM + ld) = This page demonstrates a complete example of creating, assembling, linking, and running a simple assembly program on Linux using NASM and ld. == Example overview == The program prints the message "Eat at Joe’s!" to standard output and exits. It directly uses Linux system calls to interact with the kernel. == Source code: eatsyscall64.asm == Below is the full source code of the example program. SECTION .data ; Section...")
- 14:42, 20 October 2025 From Source to Executable: Object Modules, Linking & ELF (hist | edit) [2,488 bytes] Bfh-sts (talk | contribs) (Created page with "= From Source to Executable: Object Modules, Linking & ELF = This page describes how source code becomes an executable program, what object modules are, and how linking combines them into a runnable file. == From source to binary == A program written in assembly language must be translated before a computer can execute it. The process involves two major steps: 1. Assembling – translating human-readable mnemonics into machine code. 2. Linking – combining one or m...")
- 14:42, 20 October 2025 Machine Code & Assembly: Mnemonics, Assemblers, ISA (hist | edit) [2,394 bytes] Bfh-sts (talk | contribs) (Created page with "= Machine Code & Assembly: Mnemonics, Assemblers, ISA = This page explains what machine code is, how assembly language represents it symbolically, and how an assembler translates it into executable code. == Machine code == A computer program is a sequence of instructions that the CPU executes. Each instruction is encoded as a pattern of bits that the CPU understands. Example: The bit pattern 10011100 in x86 machine language tells the CPU to push the flags registe...")
- 14:41, 20 October 2025 Development Process: Overview & History of Programming (hist | edit) [3,275 bytes] Bfh-sts (talk | contribs) (Created page with "= Development Process: Overview & History of Programming = This page introduces the origins of programming and explains how programming evolved from hardware manipulation to high-level languages. == What is programming? == Programming means instructing a computer what to do. This is usually done using high-level programming languages such as Kotlin, C#, or Python. High-level languages abstract away the hardware and make code easier to read and write. However, und...")
- 14:41, 20 October 2025 Troubleshooting Encodings: Mojibake, Detection & Conversion Tools (hist | edit) [3,286 bytes] Bfh-sts (talk | contribs) (Created page with "= Character Encoding in Practice = Character encoding defines how text is represented as bytes in memory or files. Understanding it is crucial for preventing data corruption, display errors, and security issues. == Why encoding matters == Every text you see on a screen — whether a document, website, or code — is stored as bytes. When software reads text, it must interpret those bytes using the **correct encoding**. If it uses the wrong one, characters appear g...")
- 14:41, 20 October 2025 Working with Text Files vs Binary Files (Editors, Formats, Tools) (hist | edit) [3,980 bytes] Bfh-sts (talk | contribs) (Created page with "= Binary vs Text Files = Computers store all data as binary — sequences of bits (0 and 1). However, not all binary data is meant to be read by humans. This page explains the difference between **binary files** and **text files**, how they are encoded, and why the distinction matters. == File types == Files can be divided into two broad categories: {| class="wikitable" ! File Type !! Examples !! Description |- | **Text files** || .txt, .html, .csv, .md, .c, .java...")
- 14:40, 20 October 2025 Unicode: Concepts, Planes & 5-Layer Architecture (ACR/CCS/CEF/CES/TES) (hist | edit) [4,905 bytes] Bfh-sts (talk | contribs) (Created page with "= Unicode and Character Encoding = Unicode is the global standard that unifies all text characters across languages and writing systems. It assigns every symbol — letters, digits, punctuation, emojis, and control marks — a unique number called a *code point*. This allows all languages to coexist in a single consistent system. == Why Unicode was needed == Before Unicode, computers used many different and incompatible encodings such as ASCII, ISO-8859, and Windows...")
- 14:40, 20 October 2025 Legacy Encodings & Code Pages (EBCDIC, ISO-8859, CP1252) (hist | edit) [4,049 bytes] Bfh-sts (talk | contribs) (Created page with "= Legacy Encodings & Code Pages (EBCDIC, ISO-8859, CP1252) = ASCII was revolutionary but limited to English. As computing spread internationally, new encodings extended ASCII to support more characters. This page explains these historical encodings, how they evolved, and why Unicode replaced them. == The problem with ASCII == ASCII uses 7 bits per character, giving only 128 symbols. This excludes letters with accents (é, ä, ñ), non-Latin alphabets (Cyrillic, Gree...")
- 14:40, 20 October 2025 ASCII: Code Chart, Control Codes & End-of-Line Conventions (hist | edit) [3,823 bytes] Bfh-sts (talk | contribs) (Created page with "= ASCII: Code Chart, Control Codes & End-of-Line Conventions = This page explains the ASCII standard — how it encodes characters as numbers, the role of control codes, and how text structure (like newlines) is represented. == What is ASCII == ASCII (American Standard Code for Information Interchange) was developed in the early 1960s to unify how computers represent text. Before ASCII, each manufacturer used its own incompatible encoding. ASCII defines a mapping bet...")
- 14:40, 20 October 2025 Typographic Concepts: Graphemes, Glyphs, Ligatures, Fonts (hist | edit) [3,047 bytes] Bfh-sts (talk | contribs) (Created page with "= Typographic Concepts: Graphemes, Glyphs, Ligatures, Fonts = Before text can be stored digitally, it must first be understood linguistically and visually. This page introduces the key typographic and linguistic terms that underlie all character encoding systems. == Grapheme == A grapheme is the smallest unit of a writing system of a given language. In computing, it roughly corresponds to what we call a **character**. * Examples: * “A” — Latin alphabet grap...")
- 14:40, 20 October 2025 Text & Data Types: Interpreting Bits (hist | edit) [4,756 bytes] Bfh-sts (talk | contribs) (Created page with "= Text & Data Types: Interpreting Bits = This page explains what a data type is, how the same bit pattern can mean very different things, and why consistent interpretation is critical for text processing and security. == Why data types matter == Inside a computer, everything is stored as 0s and 1s. The meaning comes from the data type: how we interpret the bit pattern and which operations we allow on it. Typical questions: * 01000010011010010110010101101100 — is this...")
- 14:39, 20 October 2025 Floating-Point in Practice: Absorption, Non-Associativity and Comparisons (hist | edit) [3,548 bytes] Bfh-sts (talk | contribs) (Created page with "= Floating-Point in Practice: Absorption, Non-Associativity and Comparisons = Floating-point arithmetic in computers is limited by precision, which can lead to rounding errors and inconsistent results when performing sequential operations. This page discusses key pitfalls such as absorption and equality comparison issues, and how to handle them properly. == Non-Associativity == Floating-point operations are **not associative**, meaning that `(a + b) + c` may produce a d...")
- 14:39, 20 October 2025 IEEE 754 Formats, Special Values and Rounding Modes (hist | edit) [3,973 bytes] Bfh-sts (talk | contribs) (Created page with "= IEEE 754 Formats, Special Values and Rounding Modes = This page covers the standard IEEE 754 formats for floating-point numbers, including their bit structure, special values, and rounding behaviors. == IEEE 754 Formats == IEEE 754 defines several binary floating-point formats. The three most common are: <syntaxhighlight lang='text'> Format | Bits | Sign | Exponent | Mantissa | Bias ------- | ---- | ---- | -------- | -------- | ---- Single pr...")
- 14:38, 20 October 2025 IEEE 754 Floating Point: Mantissa, Exponent, Bias and Hidden Bit (hist | edit) [3,941 bytes] Bfh-sts (talk | contribs) (Created page with "= IEEE 754 Floating Point: Mantissa, Exponent, Bias and Hidden Bit = This page explains the IEEE 754 standard for floating-point numbers, which defines how real numbers are represented and calculated on modern CPUs. == Motivation == Fixed-point numbers have constant precision, which limits range and accuracy. For scientific and engineering calculations, numbers may vary from very large to very small. To handle this efficiently, computers use *floating-point represen...")