Return Styles: Pseud0ch, Terminal, Valhalla, NES, Geocities, Blue Moon. Entire thread

INVENT THE WORST PROGRAMMING LANGUAGE

Name: Anonymous 2006-07-09 1:18

1. you can define keywords, operators, grammar rules, general concepts endorsed by the language, etc.
2. do your worst
3. we are starting from the ground up, so it is prohibited to import complete keyword sets from an existing language (no OK, ALL JAVA KEYWORDS, THREAD OVER, HURRRRRRRRRR)
4. and we need a name for this language as well

Name: Anonymous 2006-07-09 2:35

Make it stictly OO.

Name: Anonymous 2006-07-09 2:38

Er, isn't brainfuck more or less the worst programming language ever?

Name: Anonymous 2006-07-09 3:36

>>3
whitespace

Name: Anonymous 2006-07-09 3:53

Malborge.

Name: Anonymous 2006-07-09 3:57

Variables must be preceeded with a dollar sign
*rimshot*

Name: Anonymous 2006-07-09 4:14

Prefix global variables with @@, and class variables with self. Whitespace is significant. Typing is entirely static, except for globals. Overloading is mandatory. Memory-handling is explicit stack manipulation.

Name: Anonymous 2006-07-09 7:13

make an enterprise edition

Name: Anonymous 2006-07-09 8:49

Yes, it must be massively overengineered.

To make up for the shit static typing, make 50 different types of iterators. Don't allow default values, and all library calls require use of imported constants, not integers.

Name: Anonymous 2006-07-09 11:16

Use a different syntax for assigning objects vs assigning primitives, eg:
set foo = bar '//object
a = b '//primitive

Let objects have a default field which is referenced automatically if you use a = b, so instead of throwing an error it just gives weird hard to track bugs.

Arrays are indexed from 1, except for certain library functions.

Name: Anonymous 2006-07-09 11:24

Line numbers. No flow control other than IF and GOTO. Static typing. Hungarian notation is mandatory as it's actually part of the language. Variable names limited to 4 characters besides prefix. No automatic conversion from one type to another. Variables are global by default. No structures nor objects. No user-defined functions; must use either eval() (eval still requires line numbers!) and a special hack to receive function parameters in an array. If functions want to return something, they need to use one of a set of global stacks (there's one per each different data type). Explicit memory management with segmented memory (segments are 4 KB each, can only allocate segments, variables can't span over several segments). Arrays are actually variable variables, so ia[1] is the same as ia1 and i[a] is the same as ia. Lines limited to 80 characters. No string literals; must use hexadecimal. Most syntactic elements are optional and infered by "DWIM" rules. For example, you can type "+", and it means add 1 to i_, because + is usually used with integers; on the left we use i_ which is the default integer variable; on the right we cannot use i_ because we already used it so we use 1 (because 0 would have little sense). User must learn all of this to use it.

Name: Anonymous 2006-07-09 12:32

can't... java

Name: Anonymous 2006-07-09 21:06

Code is compiled against a proprietary suite of large, slow libraries, using the proprietary compiler.

Name: Anonymous 2006-07-10 2:18

The only characteristic of viagra: makes your penis erect, therefore it makes it bigger.  The only thing that gets bigger in programming that I can think of is a unit of measure.

Obviously we must ignore all other units of measure and make VIAGRA synonymous with bytes. Allocate VIAGRAs of memory.

Name: Anonymous 2006-07-10 5:22

If we have VIAGRA, we must have SEX.

A language that makes casting integers to longs implicit is too easy. We must make any such operation explicitly require the SEX (Sign EXtend) operator.

The opposite (long -> int, int -> char, etc) is the entirely arbitrary BOBBITIZE.

Name: Anonymous 2006-07-10 6:59

All arithmetic operations must be written in either prefix or postfix notation. Only both notations can be used; the compiler determines weather prefix or postfix has been used in any given expression.
Eg: the expression 3 + 5 * 20 / (7 - 2) can only be written as
/ + 3 * 5 20 - 7 2 (prefix) OR
3 5 20 * + 7 2 - / (postfix)

Also, compiler errors should return line numbers in binary, and the actual error descriptor should be in the form of a short riddle.

Name: Anonymous 2006-07-10 7:30

>>35
forgot: The output would be:

please insert a number: 12
hello world, the number you entered was 12

Name: Anonymous 2006-07-10 12:28

string literals should be represented as linked lists of chars thusly:
((H((e((l((l((o(( ((W((o((r((l((d((!((NULL))))))))))))))))))))))))))

(note that the parentheses tokens are double parentheses so that you know they are not a literal parenthesis.)

this representation has the obvious advantage of allowing you to concatenate two strings in O(1) instead of O(length of second string).

Name: Anonymous 2006-07-10 14:07

here's what i've got so far, explaination in next post:

10inport[nulltermstringNulltermstringLength];
20inport[linenumberNulltermstringLength];
30inport[uintNulltermstringLength];
40inport[uintAllocateMemory];
50inport[variableAllocateMemory];
60inport[linenumberAllocateMemory];
70inport[uintUintToNulltermstring];
80inport[stringUintToNulltermstring];
90inport[linenumberUintToNulltermstring];
100inport[nulltermstringPrintNulltermstring];
110inport[linenumberPrintNulltermstring];
120inport[uintPrintUint];
130inport[linenumberPrintUint];
140variable[uintBottles];
150|144:==dereference[uintBottles];
160variable[nulltermstringBottlesOfBeer];
170'\ bottles\ of\ beer\0':==dereference[nulltermstringNulltermstringLength];
180goto[linenumberNulltermstringLength];
190dereference[uintNulltermstringLength]:==dereference[uintAllocateMemory];
200dereference[uintAllocateMemory]+1:==dereference[uintAllocateMemory];
210nulltermstringBottlesOfBeer:==variableAllocateMemory;
220goto[linenumberAllocateMemory];
230' bottles of beer\0':==dereference[nulltermstringBottlesOfBeer];
240variable[nulltermstringOnTheWall];
250|15:==dereference[uintAllocateMemory];
260nulltermstringOnTheWall:==variableAllocateMemory;
270goto[linenumberAllocateMemory];
280' on the wall\0':==dereference[nulltermstringOnTheWall];
290variable[nulltermstringTakeOneDown];
300|42:==dereference[uintAllocateMemory];
310nulltermstringBottlesOfBeer:==variableAllocateMemory;
320goto[linenumberAllocateMemory];
330'. Take one down, pass it around, \0':==dereference[nulltermstringTakeOneDown];
340variable[nulltermstringBottles];
350|4:==dereference[uintAllocateMemory];
360nulltermstringBottles:==variableAllocateMemory;
370goto[linenumberAllocateMemory];
380dereference[uintBottles]:==dereference[uintUintToNulltermstring];
390nulltermstringBottles:==nulltermstringUintToNulltermstring;
400goto[linenumberUintToNulltermstring];
410nulltermstringBottles:==nulltermstringPrintNulltermstring;
420goto[linenumberPrintNulltermstring];
430nulltermstringBottlesOfBeer:==nulltermstringPrintNulltermstring;
440goto[linenumberPrintNulltermstring];
450nulltermstringOnTheWall:==nulltermstringPrintNulltermstring;
460goto[linenumberPrintNulltermstring];
470|153:==dereference[uintPrintUint];
480goto[linenumberPrintUint];
490|100:==dereference[uintPrintUint];
500goto[linenumberPrintUint];
510nulltermstringBottles:==nulltermstringPrintNulltermstring;
520goto[linenumberPrintNulltermstring];
530nulltermstringBottlesOfBeer:==nulltermstringPrintNulltermstring;
540goto[linenumberPrintNulltermstring];
550nulltermstringTakeOneDown:==nulltermstringPrintNulltermstring;
560goto[linenumberPrintNulltermstring];
570dereference[uintBottles]-1:==dereference[uintBottles];
580dereference[uintBottles]:==dereference[uintUintToNulltermstring];
590nulltermstringBottles:==nulltermstringUintToNulltermstring;
600goto[linenumberUintToNulltermstring];
610nulltermstringBottles:==nulltermstringPrintNulltermstring;
620goto[linenumberPrintNulltermstring];
630nulltermstringBottlesOfBeer:==nulltermstringPrintNulltermstring;
640goto[linenumberPrintNulltermstring];
650nulltermstringOnTheWall:==nulltermstringPrintNulltermstring;
660goto[linenumberPrintNulltermstring];
670|133:==dereference[uintPrintUint];
680goto[linenumberPrintNulltermstring];
690|25:==dereference[uintPrintUint];
700if[410]dereference[uintBottles]:==0;
710else[720];
720return;

Name: Anonymous 2006-07-10 14:07

from >>38
main features:
line numbers
hungarian notation
no whitespace
no functions (only gotos, arguments are passed with global library variables)
all numbers must be in octal
string encoding is EBCDIC
strings use single quotes, not double
no comments allowed
variables are pointers
too late i realized that all caps must be used, no lowercase

finer points:
keywords are used with the form: keyword[thing being modified by keyword]
if-statements work thus: if[line number to jump to if false]statement to test
assignation goes: value to be assigned :== where to assign it; backwards of most languages
testing equality also uses :==
for initializing nulltermstringBottlesOfBeer, i showed how you could use NulltermstringLength, but for the other strings i just coded the size directly cause it's easier (in this case)

keywords so far:
inport (not import)
variable
dereference
goto

Name: Anonymous 2006-07-10 14:18 (sage)

go do something productive, faggots.

Name: Anonymous 2006-07-10 14:33 (sage)

>>40
like trolling /prog/, for instance

Name: Anonymous 2006-07-11 1:56

>>38
great, we thank you for your contributions!
i think the keyword "return" to end the program is wonderful.

Name: Anonymous 2006-07-11 2:16

>>38
Jesus Christ, it is beautiful

Name: Anonymous 2006-07-11 3:04

Been done already. See INTERCAL for an example. Numbers are input as two decimal octets, there's COME FROM, you have to say PLEASE in the source often enough, file input and output occurs in roman numerals. (or was it ONE TWO NINE THREE SEVEN and so forth?) Conditional execution of code happens by suspending and reinstating execution of certain COME FROM and/or other lines.

Yeah, all been done before.

Name: Anonymous 2006-07-11 7:31

>>60
What admins...

Name: Anonymous 2006-07-11 23:56

THREADS EXISTING NO LONGER

Name: Anonymous 2006-07-12 2:47

INTERCAL isn't the worst language. Malbolge is, or would be if someone hadn't done a cryptanalysis.

Name: Anonymous 2006-07-12 12:15

>>9
i am a poor c-tard, explain how these 50-odd iterators would work for me?

more ideas:

the parsing of nulltermstrings will be done by functions like NulltermstringToUint, which will take the uintNulltermstringToUintSource'th character of nulltermstringNulltermstringToUint and place it in uintNulltermstringToUintDestination.

however, there will also be a stackstring datatype in which strings are uints stored on a stack. stackstrings can then be parsed by popping between stacks, analysing and modifing as we go.

(and now that we've defined string handling functions, we can write quines!)

obviously, converting between types is not automatic, but must be done with functions. uintNumber:==sintNumber is an error, we must use the UintToSint function.

allocating memory has been done, and i like the idea of using strictly segmented memory, and allocating only single segments, but the segment size should probably be something more like 256 (or 16?) bytes rather than 4K, as this would make string handling much more difficult.

another thing that should be worked out is memory deallocation. should this just use another function (e.g. free() in c), or can we come up with a better method?

oh, and we should probably have a method of self-modification.

finally, we still need a name for this language. i've been calling it 4code as a working name, but that's not a very impressive name

Name: Anonymous 2006-07-14 15:02

Call it ANONYMOUS C

Name: Anonymous 2006-07-15 0:55 (sage)

how about world4ch script

Name: Anonymous 2006-07-15 1:29

all keywords and functions will start with either l (L) or I (capital i) followed by five numbers. bracket equivelents in C will be } to open a block and { to close it. line comments begin with #\#/* . there are no block comments. also, things must be indented with 9 spaces AND have the brackets.

everything must have a ! at the end of it. variables are referenced in strings with $[variablenameq


I98276! l39732!(l82765!) } #\#/* defining a function
         I32948! l82765!;      #\#/* print the argumnt

         l202834!  = l298376!();
 
         I32948!("HELLO $[l202834q");
{

l39732!(!"hay wats ur name?!");

Name: Anonymous 2006-07-15 2:26

It's just like java, except you have to write every thing in binary..
I call it OOH Binary!

Name: Anonymous 2006-07-15 13:35

ALL FUNCTIONS ARE ANONYMOUS
ALL STATEMENTS MUST BE WRITTEN IN UPPER CASE. TYPING IN LOWER CASE WOULD BE A SYNTAX ERROR BECAUSE AS EVERYONE KNOWS CAPS LOCK IS CRUISE CONTROL FOR COOL.

Name: Anonymous 2006-07-15 14:21

FCOOLS - FourChan's Object Oriented LanguageScript.
Particularly evil because we never implemented anything OO. And wtf is LanguageScript? But anyone who takes it at face value will be like "damn how sweet is that?" and start coding.

That or wappascript.

Name: Anonymous 2006-07-16 3:16

>oh, and we should probably have a method of self-modification.

this is a REQUIRED FEATURE of this language, for sure!!
explicit support for self-modifying code

proposal:
there is a pseudovariable/function that returns the address of the "program counter" or currently executing instruction.  something like "instrptr"

there is another (library?) function that takes a block of code as an argument and returns its machine language opcodes.

using these and function pointers we could have a lot of fun.  buffer overflows would actually need to be necessary parts of your program.

Name: Anonymous 2006-07-16 13:21

the letter E inside a string causes the remaining part of the string (until Q for Quit) to be evaluated as program code. there is no way to disable this other than to escape those letters with four backslashes.

Name: Anonymous 2006-07-16 22:28

To program in the language, you must first define all commands you will use.  To define them, you must only use the language you are writing in.  Therefore, the code will reference itself.  There is only one pre-written command, which is to store the information in a random (even if it's already in use) memory location.  There can only be one memory location in use by the language at a time.  It will be hailed for its space-saving capabilities, and forced on all programmers.

Name: Anonymous 2006-07-16 23:38

MODS /B/ IS NOT WORKING PLZ FIX CUZ I LIEK /B/. KTHNKSBAI.

Name: Anonymous 2006-07-19 19:32

All types are objects, and all variables are pointers. All operators are called exactly the same way functions are. For example, to add x to y:

x->+(y);

Furthermore, there is no heap. There is no such thing as a return value for a function, but rather, what is returned is the object called; i.e. the above code returns the pointer to 'x'.

So to perform (x+y)/(u-v) and store it in z, you do:

int a,b,z; (z->+((a->+(x))->+y))->/((b->+(u))->-v);

Name: Anonymous 2006-07-19 19:33

*stack

Name: Anonymous 2006-07-19 19:34

Oops, also forgot function brackets around y and v. Oh well.

Name: Anonymous 2006-07-20 20:33

It's called HTML.

Name: Anonymous 2006-07-20 20:41 (sage)

>>46
Too easy to comprehend, uses already existing syntax.

Name: Anonymous 2006-07-21 9:35

All characters are in morse code.

Name: Anonymous 2006-07-22 23:09

lol. I like that Idea. Otherwise...

OPERATION AND RECALL LEAP-YELLING (aka ORLY)

This is the language used by SONY on their music/data CD's

A sample page looks like this:
>>hay_guys !!!
--what.happen.?
>>set *bomb* if chance < 0
--launch zig.drm
>>terminate if (cat > 999|divide < -1)
--talkback +tracert {infinite loop}
>>reboot if (tits|gtfo)<1

Name: Anonymous 2006-07-22 23:17

I think we should design a number system which will be based on syllables. 1,7,11,27,107,117, etc

And do it backward. Also, I like >>18's idea of syntax errors in the form of a short riddle. But perhaps they should be in the form of a small dose of ritalin, just to keep the programmers on the edge.

Name: Anonymous 2006-07-23 0:35

10 REM Hello World in BASIC
20 PRINT "Hello World!"
30 END

Name: virilius 2006-07-23 22:32

its aribic translitrated with the greek alphabet and then spoken into a microphone with a bad text2speech prog :)

Name: Anonymous 2006-07-25 14:19

>>53
1,7,11,27,107,117

Isn't 107 pronounced "one hundred AND seven", as in you need the 'and' for 101-109? 101 would work there.

Name: Anonymous 2006-07-25 15:11

>>56
I think Americans say 'one-hunner-sevn'.

Name: Anonymous 2006-07-25 17:18

>>57
i'm american, but i say 'a hunnerd seven', i think i say 'one hundred seven' when i'm trying to speak clearly.

but from a bad programming language standpoint, this is a feature. some compilers use the 'and', and some don't. no bad programming language should have good cross-compiler portability

Name: Anonymous 2006-07-25 19:03

>>58
but from a bad programming language standpoint, this is a feature. some compilers use the 'and', and some don't. no bad programming language should have good cross-compiler portability
I stand corrected.

Name: Anonymous 2006-07-26 9:01

>>58
Then 77 would be the portable way to write it, but you'd be out of luck for anything higher.

Name: Anonymous 2006-07-26 9:05 (sage)

>>60
scratch that, the numbers after 77 would have to be 27000, 77000, 27 billion, 77 billion... is billion 3 syllables? maybe quadrillion.

Name: Anonymous 2006-07-26 10:05

Quadrillion still won't work. 77000 == 27 quadrillion

You'd have to do something like 21,001,000 , 27,001,000 , 20,001,001,000 , 21,001,001,000 , 27,001,001,000 , etc.

Name: Anonymous 2006-07-27 0:36

All numbers must be written in binary.

Name: Anonymous 2006-07-27 1:19

No, tits.

Name: Anonymous 2006-07-27 1:45

>>63
>All numbers must be written in unary.

Fixed.

Name: Anonymous 2006-07-27 3:05

>>65
0000 00000000000000 000 0 00000000000000 00000000 0 0 00000 0 000000000000000 0 00000000000

Name: Anonymous 2006-07-27 10:07

There's a version of intercal where everything is written in trinary.

Name: Anonymous 2006-07-27 14:39

>>65
it should be negative unary, so you can represent negative numbers without having to use a pesky negative sign. i.e. 0 = 0, 00 = 1, 000 = -1, 0000 = 2, 00000 = -2, etc.

Name: Anonymous 2006-07-27 15:44

>>68
just use 2's complement: 256 zeroes = -1

Name: Anonymous 2006-07-29 16:58

>>40
I just got it -- unlambda is the /b/ of programming languages. All functions are anonymous and BOY OH BOY are they LEGION.

Name: Anonymous 2006-07-30 12:47

>>70

looks like you need to MURK LOAR

Name: Anonymous 2006-08-01 4:29

ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER! ALL HAIL KING BOOKER!

Name: Anonymous 2006-08-01 5:07

OK ALL JAVA KEYWORDS, THREAD OVER, HURRRRRRRRR

Name: Anonymous 2006-08-02 7:12

>>73
ero java == worst, language, etc.

Name: NonymousQ 2006-08-03 0:14

Anything .NET. VBScript, JScript, whatever. Just fucking sucks.
Other than that, let's see you one needs to make a really bad language..... You would need to use multiple file types that achieve mainly nothing, or not much. So let's go with .f for functions and classes, and .i for their implementation, and .head for globals
Variables created in their implementaion files (.i) can only be (re)used in that same file. i.e Variable q is created in imp.i, can only be used in imp.i . Exception: if q is a global, declared in a .head file.
What else...
The language is only ported to Fedora Core 2 (Linux), and is oddly still being heavily developed. There is no garbage collection, and everything instantly demands 90% of your availible system resources.

Creating an executable is nearly impossible; you have to give the compailer random, useless flags just to create a .compiled file, which in turn then needs to be compiled into the final executeable.




Result: WTF is wrong with me?

Name: Anonymous 2006-08-09 7:59 (sage)

Name: Anonymous 2007-07-05 7:03 ID:1yhvYsoZ

already been done its called C++

Name: Anonymous 2007-07-05 7:33 ID:9oJodBBC

>>77
Bumping faggot

Name: Anonymous 2007-07-06 15:12 ID:ebvSFlGJ

you MUST type variables in diffrent caps everytime you refrence it.

time=0
TIME=2
Time=tIme+2

if TiME=4

repeating the variable in the same caps is a SYNTAX ERROR

Name: Anonymous 2007-07-06 15:19 ID:ICIivaKb

go away

Name: Anonymous 2007-07-06 19:48 ID:9Ovxq4eu

>>79
You know, this makes some sense, actually. It enforces the principle that variables with larger scopes should have more descriptive names.

Name: Anonymous 2007-07-06 19:50 ID:ICIivaKb

    ┌─┬──┬──┬──┬──┬──┬──┬──┬─┐
    ├─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬┤
    ├┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┤
    ├┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┤
    ├─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬┤
    ├┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┤
    ├┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┤
    ├─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬┤
    ├┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┤
    ├┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┤
    ├─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬┤
    ├┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┤
    ├┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┤
    ├─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬┤
    ├┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┤
    ├┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┤
    ├─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬┤
    ├┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┤
    ├┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┤
    ├─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬┤
    ├┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┤
    ├┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┴┬─┤
    └─┴──┴──┴──┴──┴──┴──┴──┴─┘

Name: Anonymous 2007-07-06 20:46 ID:tNJHoA2g

Very simple.

Read code.
On Code: Random error, then FREEZE.

Name: Anonymous 2007-07-06 21:08 ID:APpULTHM

you must start EVERY line of programing with four arrows >>>>
and comments are written like this:
/BEGINING_OF_A_SINGLE_LINE_COMMENT/this is a comment/ENDING_OF_A_SINGLE_LINE_COMMENT/

Name: Anonymous 2007-07-06 21:16 ID:APpULTHM

and certain commands should only work 27% of the time XP

Name: Anonymous 2007-07-06 21:47 ID:HwxuKK9s

cbf to read entire thread

forced indentation of code is a must have

Name: Anonymous 2007-07-07 9:00 ID:BBvas4ZD

No variables, Instead, you must allocate memory addresses manually. Additionally, you can only allocate data to one byte at a time.

Name: Anonymous 2007-07-07 9:05 ID:+284FShd

>>87
DEY CALL DAT ASM FOO

Name: Anonymous 2007-07-07 10:37 ID:yXC27PjZ

python

Name: Anonymous 2007-07-07 10:49 ID:zG75UExX

Make it so the compiler takes a 1 min break every 5 seconds of compileing.

Name: Anonymous 2007-07-07 11:25 ID:BoKx39EH

Compiler commandline parameters should be in enterprise-quality XML.

Name: Anonymous 2007-07-07 19:31 ID:aaxCRy7D

They already made it, it's that turing-complete XML language.

Name: Anonymous 2007-07-07 19:34 ID:7d4C1qgD

>>92
XSLT?

Name: Anonymous 2007-07-08 1:50 ID:tWLqLTod

>>92
*touring

Name: Anonymous 2009-01-14 14:44

FAGGOT

Name: Anonymous 2010-06-07 6:48

Hi, I can spam /prog/ too, you faggot.

Also, smoke weed everyday.

Name: Anonymous 2010-06-26 10:00

ur gay

Name: Anonymous 2010-06-26 15:29

Here's what I got:
* calls a numbered primitives.
@ calls a value on the stack.
[ defines a function.
~ within a function defines arguments.
$ calls a function.
^ is an if statement. In needs to be followed by at least one [] block.
% is else.

*0 = eqauls
*1 = plus
*2 = minus
*3 = mult
*4 = div
*5 = mod
*6 = ==
*7 = >
*8 = <
*9 = ||
*10 = &&

I once implemented this. It's insanely easy and really satisfying.

Name: Anonymous 2010-06-26 15:38

>>98
Oh and # is return

Factorials:
!this defines a function on the 0 place on the function stack with the ability to calculate factorials
!there are already no need for parens because it's polish notation
[ 0 ~0 ^(*10 @0 0) [ # 1 ] % [ # *3 @0 $0 *2 @0 1 ] ]
!this is how you call it
$0 5
returned 120

Name: Anonymous 2010-06-26 15:42

>>47
A programming language requires stacks to be Turing compatible.

Name: Anonymous 2010-06-26 16:25

>>100
A damnable lie!

Newer Posts
Don't change these.
Name: Email:
Entire Thread Thread List