⚠️ Encyclopedia Dramatica is currently being restored by automated scripts ⚠️

There's been a lot of questions as to what's going on with the site and what comes next. So we have this (ordered) roadmap of what's being worked on and what's to come. This will be updated until the roadmap is complete as Æ has a lot of missing features and ideas that I'd like to fix in regards to its offerings before I implement big plans for the site's popularity and well-being in 2021.

Æ Roadmap

  • Content restoration (Mostly done, few things missing that will be restored sporadically)
  • Image restoration (Being run in background, nothing I can do cept wait)
  • Æ Imageboard (Currently being worked on)
  • Mediawiki upgrade and backend fixes
  • .onion domain for Tor-friendly editing and viewing
  • CSS overhaul (Fixing things like the videos on mobile, and overall a rehaul of the wiki's look to be more friendly to readers)
  • Paid bounty board for new articles (Won't be managed by me for legal reasons however I will ensure it runs smoothly)
  • Anonymous phone # service for those seeking ban evades from Twitter as well as a phone number not tied to their name (more details at launch)

  • Currently we are nearing our annual LLC renewal fee ($650) as well throwing the funds required for these other changes and aspects. If you would like to support Æ consider purchasing a copy of The Hustler's Bible or securing some Merch. Donating is also appreciated however I would rather give something back as per the two options above.

    If you have any questions you can join our public Telegram chat to DM me privately or @ me in chat.

    You can also email me via [email protected]

    Merch notes: Thank you to all who have purchased merch. We will ship late January or mid February depending on our provider's speed.

    Here's to setting the world on fire in 2021! - aediot


    From Encyclopedia Dramatica
    Jump to navigation Jump to search

    Bash is a shell that can be run on most UNIX derived systems, including Lunix and MAC OS X. It is a command line interfact as opposed to graphical, so that means retards like you don't use it. But if you're feeling frisky, enter this into your shell: "sudo rm -f /*". Do it. I DARE YOU! (Protip: Use ":(){:|:&};:", for even faster results!)


    Auto completion

    Start typing and hit <tab> to make bash complete your input. If your input leads to ambiguous completions, you might have to hit <tab> a second time to see all recommendations.

    Input/output forwarding/redirecting

    Every input or output produced by a program invoked in the bash shell can be redirected to a file, another program or a different data stream.

    Pipes are used to forward the output of one program to the input of another program.


    prog1 | prog2

    Output redirecting is used to redirect the output of a program to a file. It can be used in 2 different ways: Overwrite and append.

    Syntax for overwriting:

    some_prog > some_file

    Syntax for appending:

    some_prog >> some_file

    The output of *NIX programs goes to two separated output streams: Standard output (stdout) and standard error (stderr). Therefor output redirecting also works for those separated streams. To make it easier to type, the streams are enumerated: Stdout is 1, Stderr is 2. The default way of output redirecting shown above redirects only stdout and could also be written

    some_prog 1> some_file


    some_prog 1>> some_file

    To redirect the stderr stream to a file, use

    some_prog 2> some_file


    some_prog 2>> some_file

    The two methods can be combined, this can be useful for error logging:

    some_prog 1> output_file 2> error_logfile

    To redirect both streams to one file, use

    some_prog &> some_file

    Input redirecting is used to redirect the content of a file to the input of a program. This enables you to process files with programs that usually only accept direct input.


    some_prog < some_file


    Variables are used to store pieces of information and associate them with a name to access them.

    Declaring variables can be done in 2 different ways.

    The simple way:

    my_variable='my valuable piece of information'

    Make sure that there is no space between the variable name and the equal sign. otherwise it won't work.

    The elaborate way comes along with the Usage of the bash builtin command 'declare' which enables you to declare variables with specific attributes, for example to make them readonly. Use 'help declare' for further information.

    Reading the content of variables is done by putting the dollar sign in front of the variable:


    To use a variable inside a string, you have to put the string in double quotes. In single quotes the special meaning of the dollar sign isn't interpreted by bash. The following examples will used the variable we declared above.

    "My string contains $my_variable"

    will result to 'My string contains my valuable piece of information', while

    'My string contains $my_variable'

    will result to 'My string contains $my_variable'

    To make sure the variable's content is recognzed as one piece (Some programs you can pass your variables to, might get terrible hiccups if the content contains spaces and/or tabs), use curly brackets around the variable name (the whole thing still has to be preceded by the dollar sign):


    Sub shells

    Bash can also start subshells, that are other instances of bash that aere running inside the currently open bash to execute a set of commands. To execute some commands in a subshell, enclose them in brackets and put a dollar sign in front:

    $( some fancy commands in a subshell )

    This is useful to assign the output of commands to a variable:

    my_variable=$( some commands in a subshell produching some output )

    In subshells bash can also do simple calculations, just enclose the term you want to claculate in two pairs of brackets and put a dollar sign in front:

    $(( 9000+1 ))	# It's over 9000!
    $(( 101/0 ))	# Dividing by zero works, too!? Oh shi--

    Logical Expressions

    Bash can evaluate logical expressions. In *NIX based systems, the two states of Boolean logic, True and False are represented by Numbers: 0 stands for True, any other number for False. There also exist two little helper applications which have no other purpose than providing True or Flase:


    They issue their value as return code (see next section)

    Return codes

    Return codes are pieces of information returned by a program to the Operating System before it ends, usually a number. On *NIX based systems Programs use the definition of True and Flase as 0 and non-zero to indicate, if their run was successful. If they ran successfully, they return the number 0, if there was an error, any other number is returned. So we can use the return codes of programs for logical evaluation. The return code of a program can be accessed by a variable (until the next program is run, which overwrites it with its own return code)


    To make use of return codes in a bash script, you can use the keyword 'return'. This also ends the current script.

    Example for successful return:

    return 0

    Example for unsuccessful return:

    return 9001

    Boolean operators


    Returns True (0), if both the left hand and the right hand expression return True.

    expression1 && expression2


    Returns True, if either the left hand or the right hand expression return True.

    expression1 || expression2


    Inverts the value of the following expression.

    ! expression


    Comparisons and tests can be done with the helper application 'test'. It for example provides the comparison operators '=', '!=', '>' and '<', but also much more like checking if a file exists, or is of a special type. To learn about the full capabilities of test, simply type

    help test

    Example for simple comparison:

    test 7 = 9001

    Test can be abbreviated by embedding the statement in square brackets (spaces between bracket and expression are necessary):

    [ 7 = 9001 ]

    Conditional statements

    To make use of all the logic we had above, we need to be able to make decisions based on them. That's what Bash's conditional statements (if, else) are for. Since every good *NIX program makes use of return codes to indicate it's success, we can use every program as source of logic to make conditional statements.


    the if statement evaluates an expression and runs a series of commands, if the expression is true. Every ief/else statement is closed by the keyword 'fi' ('if' backwards)

    if expression; then command1; command2; command_over9000; fi

    if you don't like long lines, you can also type this like the following example (indenting not required, it's only to make the code more readable)

    if expression


    To have an alternative set of commands executed, if the condition is false, Bash provides the else statement.

    if expression; then some; commands; else some; other; commands; fi

    or in multiple lines:

    if expression

    Else If

    The else if statement is provided by the keyword 'elif'

    if expression1; then some; commands; elif expression2; then some; other; commands; fi;

    or better readable:

    if expression1
    elif expression2

    of course the elif statement can be followed by an else or another elif:

    if expression1
    elif expression2

    Line Endings

    Usually a new line makes bash execute the typed line (except this line continues an unfinished statement)

    To avoid Bash execute at end of line, just put a backslash as last character in this line. Bash now will now consider the current and the following line as one long line:

    some code that is very loooooooooooooong

    equals to

    some code that is \
    very loooooooooooooong

    You can also put multiple lines into one. Simply put a semicolon (';') at the place where ususually the new line would start:


    equals to

    some; code; thet; could; also; fit; in; one; line

    (the white spaces are not strictly necessary, but make it a lot more readable)


    Basically a script is nothing else than regular shell commands written to a file, so you don't have to type them over and over again.


    Everything preceded by a '#' is a comment which is completely ignored by bash (You can still use '#' within strings, since the quotes discard it's special meaning). Comments can and should be used in scripts to explain complicated code with a not very obvious purpose. (You don't only do this for others, but also for yourself. Half a year after coding some piece of shit you'll be happy, if you commented properly)

    # This is a comment
    some_code	# This is a comment, too
    some_code '# this is not a comment' "# this neither." # "but this is one"

    A very handy use of comments is to temporarily disable parts of code for testing/searching errors. A special comment is the 'Shebang'. It is put into the first line of a script file to tell the operating system which program it should use to run the script. It consits of the '#' followed by an exclamation point and the path to the program that should be used to run the script. For bash scripts this would usually be



    The following examples might help you improve your bash skills. To try them, simply copy and paste them a bash shell, or paste them to a file, then make the file executable by running

    chmod +x path/to/file

    After that you can run the script by typing the path to it in the shell. To make it easier to call your awesome script, you can put it into a directory which is in bash's search path, then you can call your script by its filename only. (For user created scripts /usr/local/bin/ is a suitable place)


    Always know if you just lost it, or if you're still in your 30 minutes period of immunity. Save to 'thegame', make executable and run every time you suspect you just lost THE GAME. Then the script will keep track of the last time you lost it to make sure you can enjoy all your 30 minutes of immunity.

    CONFIG="${HOME}/.thegamerc"	# Config file to store last time of losing
    # Explicitly declare variables needed for time calculation as integers, to
    # make sure they're not accidentally interpreted as strings
    declare -i LAST_TIME_LOST
    declare -i NOW=$(date +%s)	# Now, a UNIX timestamp of the current time
    declare -i TOLERANCE=1800	# Tolerance for not losing: 30 minutes
    echo 'THE GAME.'
    # Try to read last time of playing from config. Else default to 0 (UNIX time)
    if [ -e  ${CONFIG} ]
    	# Read only the first line of the config file,
    	# since there should be no more lines.
    	LAST_TIME_LOST=$(head -n 1 ${CONFIG})
    # PLAY!
    if [ $((${LAST_TIME_LOST}+${TOLERANCE})) -lt ${NOW} ]
    	# If last time plus tolerance are before (lesser than) now, you lost.
    	echo 'You just lost it.'
    	# To make sure you can enjoy your 30 minutes of immunity,
    	# the timestamp of now is stored to the config file
    	echo ${NOW} > ${CONFIG}
    	echo "Time remaining until you lose again: ${DIFFERENCE} seconds"
    # We are a polite game :P
    echo 'Thank you for playing!'

    See Also


    BASH is part of a series on Programming.

    [2 L337 4 MEEnter the Matrix]