text stringlengths 313 1.33M |
|---|
# Control Systems/System Representations
## System Representations
This is a table of times when it is appropriate to use each different
type of system representation:
+-------------------------------------+--------------+-----------+-----------+
| Properties | State-Space\ | Transfer\ | Tra... |
# Control Systems/Matrix Operations
## Laws of Matrix Algebra
Matrices must be compatible sizes in order for an operation to be valid:
Addition:Matrices must have the same dimensions (same number of rows, same number of columns). Matrix addition is commutative:
:
: $A + B = B + A$
Multiplication:Matrices... |
# Control Systems/MATLAB
## MATLAB
**MATLAB** is a programming language that is specially designed for the
manipulation of matrices. Because of its computational power, MATLAB is
a tool of choice for many control engineers to design and simulate
control systems. This page is going to discuss using MATLAB for control
... |
# Control Systems/Glossary
The following is a listing of some of the most important terms from the
book, along with a short definition or description.
## A, B, C
Acceleration Error:The amount of steady state error of the system when stimulated by a unit parabolic input.\
Acceleration Error Constant:A system metric t... |
# Control Systems/List of Equations
The following is a list of the important equations from the text,
arranged by subject. For more information about these equations,
including the meaning of each variable and symbol, the uses of these
functions, or the derivations of these equations, see the relevant pages
in the mai... |
# X86 Disassembly/Introduction
## What Is This Book About?
This book is about the disassembly of x86 machine code into
human-readable assembly, and the decompilation of x86 assembly code into
human-readable C or C++ source code. Some topics covered will be common
to all computer architectures, not just x86-compatible... |
# X86 Disassembly/Assemblers and Compilers
## Assemblers
**Assemblers "wikilink")** are
significantly simpler than compilers, and are often implemented to
simply translate the assembly code to binary machine code via one-to-one
correspondence. Assemblers rarely optimize beyond choosing the shortest
form of an instruc... |
# X86 Disassembly/Disassemblers and Decompilers
## What is a Disassembler?
In essence, a **disassembler** is the exact opposite of an assembler.
Where an assembler converts code written in an assembly language into
binary machine code, a disassembler reverses the process and attempts to
recreate the assembly code fro... |
# X86 Disassembly/Analysis Tools
## Debuggers
**Debuggers** are programs that allow the user to execute a compiled
program one step at a time. You can see what instructions are executed
in which order, and which sections of the program are treated as code
and which are treated as data. Debuggers allow you to analyze ... |
# X86 Disassembly/Microsoft Windows
## Microsoft Windows
The **Windows operating system** is a popular reverse engineering target
for one simple reason: the OS itself (market share, known weaknesses),
and most applications for it, are not Open Source or free. Most software
on a Windows machine doesn\'t come bundled w... |
# X86 Disassembly/Linux
## GNU/Linux
The **GNU/Linux operating system** is open source, but at the same time
there is so much that constitutes \"GNU/Linux\" that it can be difficult
to stay on top of all aspects of the system. Here we will attempt to
boil down some of the most important concepts of the GNU/Linux Oper... |
# X86 Disassembly/Linux Executable Files
## ELF Files
The **ELF file format** (short for Executable and Linking Format) was
developed by Unix System Laboratories to be a successor to previous file
formats such as COFF and a.out. In many respects, the ELF format is more
powerful and versatile than previous formats, an... |
# X86 Disassembly/Mac OS X
## Mach-O format overview
MacOS (Previously OS X) uses the Mach-O file format to encode
executables, object files, and shared libraries (.dylib files). Here, we
will be looking at the 64-bit version of the Mach-O format. The majority
of data in Mach-O files are \'segments\' and \'sections\'... |
# X86 Disassembly/The Stack
## The Stack
 Generally speaking, a **stack** is
a data structure that stores data values contiguously in memory. Unlike
an array, however, you access (read or write) data only at the \"top\"
of the stack. To read from the stack is said \"**to pop**\" an... |
# X86 Disassembly/Functions and Stack Frames
## Functions and Stack Frames
In the execution environment, functions are frequently set up with a
\"**stack frame**\" to allow access to both function parameters, and
automatic local function variables. The idea behind a stack frame is
that each subroutine can act indepen... |
# X86 Disassembly/Functions and Stack Frame Examples
## Example: Number of Parameters
``` asm
_Question1:
push ebp
mov ebp, esp
sub esp, 4
mov eax, [ebp + 8]
mov ecx, 2
mul ecx
mov [esp + 0], eax
mov eax, [ebp + 12]
mov edx, [esp + 0]
add eax, edx
mov esp, ebp
pop ebp
ret
```
The function a... |
# X86 Disassembly/Calling Conventions
## Calling Conventions
**Calling conventions** are a standardized method for functions to be
implemented and called by the machine. A calling convention specifies
the method that a compiler sets up to access a subroutine. In theory,
code from any compiler can be interfaced togeth... |
# X86 Disassembly/Calling Convention Examples
## Microsoft C Compiler
Here is a simple function in C:
``` C
int MyFunction(int x, int y)
{
return (x * 2) + (y * 3);
}
```
Using cl.exe, we are going to generate 3 separate listings for
MyFunction, one with CDECL, one with FASTCALL, and one with STDCALL
calling... |
# X86 Disassembly/Branches
## Branching
Computer science professors tell their students to avoid jumps and
**goto** instructions, to avoid the proverbial \"spaghetti code.\"
Unfortunately, assembly only has jump instructions to control program
flow. This chapter will explore the subject that many people avoid like
th... |
# X86 Disassembly/Loops
## Loops
To complete repetitive tasks, programmers often implement **loops**.
There are many sorts of loops, but they can all be boiled down to a few
similar formats in assembly code. This chapter will discuss loops, how
to identify them, and how to \"decompile\" them back into high-level
repr... |
# X86 Disassembly/Variables
## Variables
We\'ve already seen some mechanisms to create local storage on the
stack. This chapter will talk about some other variables, including
**global variables**, **static variables**, variables labelled
\"**const**,\" \"**register**,\" and \"**volatile**.\" It will also
consider so... |
# X86 Disassembly/Data Structures
## Data Structures
Few programs can work by using simple memory storage; most need to
utilize complex data objects, including **pointers**, **arrays**,
**structures**, and other complicated types. This chapter will talk
about how compilers implement complex data objects, and how the ... |
# X86 Disassembly/Objects and Classes
## Object-Oriented Programming
**Object-Oriented** (OO) programming provides for us a new unit of
program structure to contend with: the **Object**. This chapter will
look at disassembled classes from C++. This chapter will not deal
directly with COM, but it will work to set a lo... |
# X86 Disassembly/Floating Point Numbers
## Floating Point Numbers
This page will talk about how **floating point** numbers are used in
assembly language constructs. This page will not talk about new
constructs, it will not explain what the FPU instructions do, how
floating point numbers are stored or manipulated, or... |
# X86 Disassembly/Code Optimization
## Code Optimization
An **optimizing compiler** is perhaps one of the most complicated, most
powerful, and most interesting programs in existence. This chapter will
talk about optimizations, although this chapter will not include a table
of common optimizations.
## Stages of Optim... |
# X86 Disassembly/Code Obfuscation
## Code Obfuscation
**Code Obfuscation** is the act of making the assembly code or machine
code of a program more difficult to disassemble or decompile. The term
\"obfuscation\" is typically used to suggest a deliberate attempt to add
difficulty, but many other practices will cause ... |
# X86 Disassembly/Debugger Detectors
## Detecting Debuggers
It may come as a surprise that a running program can actually detect the
presence of an attached user-mode debugger. Also, there are methods
available to detect kernel-mode debuggers, although the methods used
depend in large part on which debugger is trying... |
# Foundations of Computer Science/Introduction
Have you ever wondered what computing is and how a computer works? What
exactly is computer science? Why---beyond the obvious reasons---is it
important? What do computer scientists do? What types of problems do
they work on? What approaches do they use to solve those prob... |
# Foundations of Computer Science/What is Computing
## What is Computing
In this course, we try to focus on computing principles (big ideas)
rather than computer technologies, which are tools and applications of
the principles. Computing is
defined by a set of principles or ideas, which underlies a myriad of
technolo... |
# Foundations of Computer Science/Information Representation
## Information Representation
### Introductory problem
Computers often represent colors as a red-green-blue (RGB) set of
numbers, called a \"triple\", where each of the red, green, and blue
components is an integer between 0 and 255. For example, the color... |
# Foundations of Computer Science/Algorithms and Programs
## Algorithms and Programs
An algorithm can be defined
as a set of steps used to solve a specific problem. For example, a cook
may use a recipe when preparing a specific type of food. Similarly, in
computer science, algorithms are the conceptual solutions used... |
# Foundations of Computer Science/Algorithm Design
## Algorithm Design
Algorithm design is a
specific method to create a mathematical process in solving problems.
One powerful example of algorithm design can be seen when solving a
Rubik\'s cube. When solving a Rubik\'s cube (of any size), it is
important to know the ... |
# Foundations of Computer Science/Algorithm Complexity
## Algorithm Complexity
\"An algorithm is an abstract recipe, prescribing a process that might
be carried out by a human, by computer, or by other means. It thus
represents a very general concept, with numerous applications.\"---David
Harel, \"Algorithmics - the ... |
# Foundations of Computer Science/Abstraction and Recursion
## Abstraction and Recursion
Programming is easy as long as the programs are small. Inevitably our
programs will grow larger and larger as we create them to solve
increasingly complex problem. One technique we use to keep our
algorithms and programs simple i... |
# Foundations of Computer Science/Recursion Revisited
## Recursion Revisited
Recursive solutions provide another powerful way to solve self-similar
problems. The example that we will examine is the binary search
solution.
### How Binary Search Works?
The process for identifying a target item in a sorted list. You s... |
# Foundations of Computer Science/Higher Order Functions
## Higher Order Functions
higher order functions offer a more powerful ways to generalize
solutions to problems by allowing blocks to take blocks as parameters
and returning a block as a return value. All other functions are called
first order functions. An exa... |
# Foundations of Computer Science/The Internet and the Web
## The Internet and the Web
The Internet and the Web give us the ability to connect to countless
resources and is molding the way our society utilizes technology for
online storage and services. We will use principles previously learned
to examine Internet an... |
# Foundations of Computer Science/Encryption
## Encryption
In order to ensure secure communication takes place encryption methods
must be used. Secure communication over the web is important for areas
such as e-commerce. Encryption is used to encode messages ensuring no
one, but the intended recipient knows the conte... |
# Foundations of Computer Science/Simulation
## Simulation
Simulation can be a very powerful way to represent real-world systems,
scenarios, and experiments. Simulation is the recreation of a real-world
system in a prepared and controlled environment. As we study different
objects and environments we see the complexi... |
# Foundations of Computer Science/Artificial Intelligence
## Artificial Intelligence
### What is A.I.?
Artificial Intelligence (AI) is the idea of building a system that can
mimic human intelligence. How we determine intelligence is based on how
people plan, learn, natural language processing, motion and
manipulatio... |
# Foundations of Computer Science/Limits of Computing
## Limits of Computing
We have studied some big ideas of computing, which allows us to perform
amazing tasks through information process. You might have gotten the
impression that if we can quantify information and design an algorithm,
we can solve any problem usi... |
# Foundations of Computer Science/Computing Machinery
## Computing Machinery
We have studied some fundamental principles of computing and seen the
power of computing demonstrated in powerful technologies that operate on
these principles. At the beginning we imagined that computing can be
done purely mechanically and ... |
# Foundations of Computer Science/Parallel Processing
Computing is fundamentally about information processes. On a digital
computer such processes are carried out via symbol manipulations in
binary logic. With the advancement in semiconducting technology we have
been able to keep making computers run faster---manipula... |
# C Programming/Why learn C?
C "wikilink") is the most commonly
used programming language for writing operating
systems. The first operating
system written in C was Unix. Later
operating systems like GNU/Linux were all
written in C. Not only is C the language of operating systems, it is the
precursor and inspiration f... |
# C Programming/History
The field of computing as we know it today started in 1947 with three
scientists at Bell Telephone Laboratories---William
Shockley, Walter
Brattain, and John
Bardeen---and their groundbreaking
invention: the transistor. In 1956, the first
fully transistor-based computer, the TX-0, was
completed... |
# C Programming/What you need before you can learn
## Getting Started
This book introduces and teaches the basics of the C programming
language and touches upon some advanced topics as well. This section
outlines the required skills and tools you\'ll need to get the most out
of this book.
### Skills and Prior Experi... |
# C Programming/Obtaining a compiler
## Dev-C++
{{ Wikipedia \| Dev-C++ }}
Dev C++ is an Integrated Development
Environment (IDE) for the C++ programming language, available from
Bloodshed Software. An updated version is
available at Orwell Dev-C++.\
C++ is a programming language which contains within itself most of... |
# C Programming/Intro exercise
## The \"Hello, World!\" Program
Tradition dictates that we begin with a program that displays a \"Hello,
World!\" greeting to the screen, followed by a new line, and then exits.
Below is the C source code that does just that. Type this code into your
preferred text editor/IDE and save ... |
# C Programming/Preliminaries
Before learning C syntax and programming constructs, it is important to
learn the meaning of a few key terms that are central in understanding
C.
## Block Structure, Statements, Whitespace, and Scope
Next we\'ll discuss the **basic structure** of a C program. If you\'re
familiar with PA... |
# C Programming/Basics of compilation
Having covered the basic concepts of C programming, we can now briefly
discuss the process of *compilation*.
Like any programming language, C by itself is completely
incomprehensible to a microprocessor. Its
purpose is to provide an intuitive way for humans to provide
instruction... |
# C Programming/Structure and style
## C Structure and Style
This is a basic introduction to good coding style in the C Programming
Language. It is designed to provide information on how to effectively
use indentation, comments, and other elements that will make your C code
more readable. It is not a tutorial on actu... |
# C Programming/Variables
Like most programming languages, C uses and processes **variables**. In
C, variables are human-readable names for the computer\'s memory
addresses used by a running program. Variables make it easier to store,
read and change the data within the computer\'s memory by allowing you
to associate ... |
# C Programming/Operators and type casting
## Operators and Assignments
C has a wide range of operators that make simple math easy to handle.
The list of operators grouped into precedence levels is as follows:
### Primary expressions
*Identifiers* are names of things in C, and consist of either a letter
or an under... |
# C Programming/Arrays and strings
Arrays in C act to store related data under a single variable name with
an index, also known as a *subscript*. It is easiest to think of an
array as simply a list or ordered grouping for variables of the same
type. As such, arrays often help a programmer organize collections of
data ... |
# C Programming/Program flow control
Very few programs follow exactly one control path and have each
instruction stated explicitly. In order to program effectively, it is
necessary to understand how one can alter the steps taken by a program
due to user input or other conditions, how some steps can be executed
many ti... |
# C Programming/Procedures and functions
In C programming, all executable code resides within a **function**.
Note that other programming languages may distinguish between a
\"function\", \"subroutine\", \"subprogram\", \"procedure\", or
\"method\" \-- in C, these are all functions. Functions are a
fundamental feature... |
# C Programming/Standard libraries
The **C standard library** is a standardized collection of
s and library routines used to implement
common operations, such as input/output and character string handling.
Unlike other languages (such as COBOL, Fortran, and PL/I) C does not
include built in keywords for these tasks, s... |
# C Programming/Beginning exercises
## Variables
### Naming
1. Can a variable name start with a number?
2. Can a variable name start with a typographical symbol(e.g. #, \*,
\_)?
3. Give an example of a C variable name that would *not* work. Why
doesn\'t it work?
### Data Types
1. List at least three da... |
# C Programming/Advanced data types
In the chapter Variables we looked at the
primitive data types. However *advanced* data types allow us greater
flexibility in managing data in our program.
## Structs
Structs are data types made of variables of other data types (possibly
including other structs). They are used to ... |
# C Programming/Pointers and arrays
!Pointer *a* pointing to variable *b*. Note that *b* stores a number,
whereas *a* stores the address of *b* in memory
(1462)"){width="180"}
A **pointer "wikilink")** is a value that
designates the address (i.e., the location in memory), of some value.
Pointers are variables that hol... |
# C Programming/Memory management
In C, you have already considered creating variables for use in the
program. You have created some arrays for use, but you may have already
noticed some limitations:
- the size of the array must be known beforehand
- the size of the array cannot be changed in the duration of your... |
# C Programming/Error handling
C does not provide direct support for error handling (also known as
exception handling). By convention, the programmer is expected to
prevent errors from occurring in the first place, and test return values
from functions. For example, -1 and NULL are used in several functions
such as so... |
# C Programming/Stream IO
## Introduction
The `stdio.h` header declares a broad assortment of functions that
perform input and output to files and devices such as the console. It
was one of the earliest headers to appear in the C library. It declares
more functions than any other standard header and also requires mor... |
# C Programming/String manipulation
A **string** in C is merely an array of characters. The length of a
string is determined by a terminating null character: `'\0'`. So, a
string with the contents, say, `"abc"` has four characters: `'a'`,
`'b'`, `'c'`, and the terminating null (`'\0'`) character.
The terminating null... |
# C Programming/Further math
The `<math.h>` header contains prototypes for several functions that
deal with mathematics. In the 1990 version of the ISO standard, only the
`double` versions of the functions were specified; the 1999 version
added the `float` and `long double` versions. To use these math
functions, you m... |
# C Programming/Libraries
A *library* in C is a collection of header files, exposed for use by
other programs. The library therefore consists of an *interface*
expressed in a `.h` file (named the \"header\") and an *implementation*
expressed in a `.c` file. This `.c` file might be precompiled or
otherwise inaccessible... |
# C Programming/Common practices
With its extensive use, a number of common practices and conventions
have evolved to help avoid errors in C programs. These are
simultaneously a demonstration of the application of good software
engineering principles to a language and an indication of the
limitations of C. Although fe... |
# C Programming/Preprocessor directives and macros
Preprocessors are a way of making text processing with your C program
before they are actually compiled. Before the actual compilation of
every C program it is passed through a Preprocessor. The Preprocessor
looks through the program trying to find out specific instru... |
# C Programming/Serialization
## Serialization
It is often necessary to send or receive complex data structures to or
from another program that may run on a different architecture or may
have been designed for different version of the data structures in
question. A typical example is a program that saves its state to... |
# C Programming/Coroutines
A little known fact is that most C implementations have built-in
primitives that can be used for cooperative multitasking / coroutines.
They are setcontext and
setjmp.
## setjmp
The function `setjmp` is used in a pair with `longjmp` to transfer
execution to a different point in the code. I... |
# C Programming/Particularities of C
C is an efficient, minimalist language that has some peculiarities that
a programmer must be aware of. To address these, sometimes a good
solution is to combine another language with C for added flexibility and
power, like the combination of Emacs-LISP and C used for Emacs.
Sometim... |
# C Programming/Low-level IO
## File descriptors
While not specified by the C standard, many operating systems provide
the concept of a **file descriptor** (sometimes abbreviated as **fd**).
While the `FILE` type from `stdio.h` and its associated
functions encapsulate the low-level details of
a stream, a file descrip... |
# C Programming/C trigraph
## Trigraphs
C was designed in English and assumes the common English character set,
which includes such characters as `{`, `}`, `[`, `]`, and so on. Some
other languages, however, do not have these or other characters which
are required by C. To solve this problem, the 1989 C standard in s... |
# C Programming/Language overloading and extensions
Most C compilers have one or more \"extensions\" to the standard C
language, to do things that are inconvenient to do in standard, portable
C.
Some examples of language extensions:
- in-line assembly language
- interrupt service routines
- variable-length dat... |
# C Programming/Mixing languages
## Assembler
See Embedded Systems/Mixed C and Assembly
Programming
## Cg
Make the main program (for CPU) in C, which loads and run the
Cg "wikilink") program ( for GPU
).[^1][^2][^3]
### Header files
Add to C program:[^4]
``` c
#include <Cg/cg.h> /* To include the core Cg runtime... |
# C Programming/GObject
Since the C Programming-Language was not created with Object Oriented
Programming in mind, it has no explicit support for classes,
inheritance, polymorphism and other OO Concepts. Neither does it have
its own Virtual Table, which is found in object-oriented languages such
C++, Java
and C#. Ther... |
# C Programming/Code library
The following is an implementation of the Standard C99 version of
`<assert.h>`:
``` c
/* assert.h header */
#undef assert
#ifdef NDEBUG
#define assert(_Ignore) ((void)0)
#else
void _Assertfail(char *, char *, int, char *);
#define assert(_Test) ((_Test)?((void)0):_Assertfail(#_Test... |
# C Programming/Statements
A **statement** is a command given to the computer that instructs the
computer to take a specific action, such as display to the screen, or
collect input. A computer program is made up of a series of statements.
In C, a statement can be any of the following:
## Labeled Statements
A state... |
# C Programming/Side effects and sequence points
In C and more generally in computer science, a function or expression is
said to have a **side effect** if it modifies a state outside its scope
or has an *observable* interaction with its calling functions or the
outside world. By convention, returning a value has an e... |
# C Programming/Standard Library Reference
## Headers
### ANSI C (C89)/ISO C (C90)
------------------------------------------ ----------------------------------------
`assert.h` Verify program assertion file
`ctype.h` Character types file.
**`errno.h`** System error numbers file
**`fl... |
# C Programming/Preprocessor reference
## Preprocessor Reference
The following preprocessor statements exist:
`Statement Subsequent items on the control line Meaning`\
`========= ==================================== =======`\
`#if conditional-expression conditional`\
`#ifdef identifier ... |
# C Programming/POSIX Reference
The **C POSIX library** is a language-independent library (using C
calling conventions) that adds functions specific to POSIX systems.
POSIX (and the Single Unix Specification) specifies a number of routines
that should be available over and above those in the C standard library
proper.... |
# C Programming/GNU C Library Reference
## Header files
---------------------------------------- ----------------------------------------------------
`argp.h` Interface for parsing unix-style argument vectors.
`argz.h` Allocate/grow argz vectors.
`envz.h`
`execinfo.h` Backtr... |
# C Programming/MS Windows Reference
## Header files
-------------------------------------- ----------------------------
`alloc.h` Dynamic memory allocation.
`conio.h` Text user interfaces.
`process.h` Threads and processes.
-------------------------------------- ----------------------------
... |
# C Programming/C Compilers Reference List
For a brief introduction to setting up and using some of the more
beginner-friendly compilers and IDEs, see ../Using a
Compiler/.
## Free (or with a free version)
- Ch_interpreter
(http://www.softintegration.com) - The software works in Windows,
Linux, Mac OS X, F... |
# C Programming/Index
This is an alphabetical index of the book.
## A
- `argv` - poorly treated
- ../Pointers and
arrays/#sizeof
- ../Arrays/
- Assignment
- ../Variables/#Declaring, Initializing, and Assigning
Variables
- ../Simple math/#Assignment
operators
- `auto`... |
# C Programming/Links
Links to online resources relating to learning how to program in C:
- *The C Book*, second
edition by Mike Banahan, Declan Brady and Mark Doran, originally
published by Addison Wesley in 1991. This version is made freely
available.
- Programming in C: A
Tutorial, by Brian W.... |
# Wikijunior:Biology/Introduction
## Introduction
**Biology** is the study of life. It helps us understand many things,
such as how our body works, how our body keeps warm, and what we are
made of. Biology is very important to know. Some things we can learn
about in biology are *genetics* (the study of human traits... |
# Wikijunior:Biology/Creatures
## Creatures
Many different creatures live on earth: plants, insects, birds, fish,
bacteria, humans and many more. They have many differences and
similarities.
<File:Monkey> of kembang island.jpg\|thumb\|Monkey <File:Pterois>
volitans Manado-e edit.jpg\|thumb\|Pterois volitans <File:M... |
# Wikijunior:Biology/Science and theory of evolution
## Science and theory of evolution
The aim of science is to understand the world better (knowledge) and to
produce new technology (innovation). Scientists develop mental models
(theories) and functional models (such as an engine). Then they test
these models thro... |
# Wikijunior:Biology/Life
## Definition of Life
Scientists have come up with over a hundred different definitions of the
term \"life\". Many definitions are similar. They usually belong to one
## Definitions
- **Enumeration of properties**\
*Life is a system that has a metabolism, can grow, multiply and mov... |
# Wikijunior:Biology/Origin of Life
## Origin of Life
!Stromatolite about 3.4 billion years
old
after the formation of the earth, there were protozoa and stromatolite.
It is not known how life evolved. There are various theories, one of
which is presented below. Living things control their internal
chemistry. A main... |
# Wikijunior:Biology/Cells
## Cells
!Plant cells
All living things are made of cells. They are the components and
building blocks of life.
**What is a cell?** *A cell is a bag of liquid that holds in the stuff
of life.*
A cell is the smallest structural and functional unit of a living
organism. The word \"cell\"... |
# Wikijunior:Biology/Tissues
! Animal muscle
tissue
## Tissues
Organisms are made of tissues. Tissues are groups of
cells that work together. Plant leaves
have tissues that capture light and make sugar. Most animals have
**muscle** tissues that help them move.
When two or more tissues work together to do one thing... |
# Wikijunior:Biology/Organs
## Organs
! A heart\|thumb Many living things have
**organs**. Your heart, brain, lungs, liver, and kidneys are all
examples of organs.
Organs are made up of two or more
tissues.
All organs have something that they do to keep you healthy. For example,
the heart pumps blood, and the lun... |
# Wikijunior:Biology/Systems
`__NOTOC__`
## Organ systems
!A diagram of the reproductive system in
women{width="250"}
Two or more organs that work together make up an **organ system**.
Organ systems are found in all different kinds of living things.
Some of the organ systems found in humans include:
- Circula... |
# Wikijunior:Biology/Kingdoms
## Kingdoms
When we look at living things we divide them up into groups and give the
groups names. This is called **classification**.
Living things are classified into groups of different sizes. The biggest
groups contain almost everything. The smallest groups have only a few
types of... |
# Wikijunior:Biology/Viruses
## Viruses
!A virus called a rotavirus, which can cause diarrhea.\|alt=Diarrhoea
causing virus,
Rotavirus.
Viruses are much smaller than other living things like
bacteria, so small that it
would take around one hundred viruses laid end to end just to make the
length of a bacterium! Viru... |
# MySQL/Introduction
## What is SQL?
For a more general introduction see the SQL Wikibook.
**S**tructured **Q**uery **L**anguage is a third generation language for
working with relational databases. Being a 3G language it is closer to
human language than machine language and therefore easier to understand
and work w... |
# MySQL/MySQL Practical Guide
## Installing MySQL
### All in one solutions
As MySQL alone isn\'t enough to run a real database server, the more
practical way to install it is to deploy an all in one
pack in this purpose,
including all the needed additional elements:
Apache and
PHP.
1. On Linux: XAMP or LAMP "wikil... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.