Scratch

nXIII wrote:

Nope. xD

Hint:6642

I'm going to stay out of your fight with Jens, except to note that Snap! uses morphic.js, and its performance, while I'm sure it could be improved upon, is already quite amazing, especially compared with BYOB3.  And, efficiency is not the only consideration.  There's an old saying: You can't argue with success.  Jens pretty much singlehandedly ("pretty much" because of a few contributions by you and others) got Snap! written in a year, including the initial investment in morphic.js.  I confess that during those first few months when he was dragging rectangles around, I felt frustrated that nothing BYOB-like seemed to be happening.  But then it was like a construction site where for months they just seem to be moving piles of dirt from one place to another and, all of a sudden, one day a steel framework appears as if by magic.

Maybe someone else could have done a better job using some other framework.  But the person who actually did it chose Morphic, and that counts for a lot.

Hi Hardmath123,

I like your idea about creating your own programming language! Don't let yourself be discouraged by "experts", rolling your own is exciting and fun and perfectly legitimate. If you break some "rules" along the way, let me know, so I can applaud 

Yeah, totally! 

bharvey, when I said efficient, I didn't mean execution time (which I really don't care about too much). I meant the amount of time and code it takes to do something. For example, just to take a list and replace each item with its factorial, here's what I'd do in Obj-C, JS and Python:

-(NSInteger) factorialOf:(NSInteger)n {
    if (n==0) {
        return 1;
    } else {
        return [self factorialOf:(n-1)]*n;
    }
}
-(void) main {
    NSString * contents = [NSArray arrayWithContentsOfFile:@"/path.txt" encoding:NSUTF8Encoding error:NSError];
    NSMutableArray *items = [NSMutableArray arrayWithArray:[contents componentsSeparatedByString:@"\n"]];
    for (int i=0; i<[items length]; i++) {
        [items replaceObjectAtIndex:i withObject:[self factorialOf:[items objectAtIndex:i]]];
    }
    [[items componentsJoinedByString:@"\n"] writeToFile:@"/path.txt" atomically:YES];
}

def factorialOf(n):
    return 1 if n==0 else factorialOf(n-1)*n

f = open("/path.txt","w+")
contents = f.readLines()
contents = map(factorialOf,contents)
f.write("\n".join(contents))

See the difference? I had to refer to like 3 class references for Obj-C, while the Python is off the top of my head. My language would ideally simplify this even more.

@nXIII I think I'll call it "PyScheme".  Which begs for the motto "I scream, you scream, we all scream for PyScheme!". 

Your language?

blob8108 wrote:

I love how much Jens and Brian's opinions differ. 

We do have differences of opinion, sometimes, but in this case we don't.  Hardmath, was I being discouraging?  That wasn't my intent.  What maybe I didn't say is that people learn by biting off more than they can chew, and sort of half-chewing it -- and then taking a compilers course to learn the state of the art. 

blob8108 wrote:

Which three are you referring to? Presumably one of them is list...

http://python.about.com/b/2007/07/26/py … uences.htm:  "Python supports several of these: strings, lists, tuples, buffers, and xrange objects."

Hardmath123 wrote:

@nXIII how do you implement a language in itself? Is it turtles all the way down? 

I have no idea what that means, but the basic idea is that you implement it in something else just enough so that you can run the real implementation, and then use that from then on.

Well it isn't turtles all the way down with computers: no matter how many interpreters and compilers are being used, eventually something is running directly on the
system's machine language.                                                                                         

Edit: OMG look at the post count it's #6666

Last edited by joefarebrother (2013-01-28 11:19:23)

I'm going to re post this because no-one appeared to comment on it

I wrote:

When we get file I/O, we should have a reporter, OPEN FILE () FOR [ v], that reports a stream (the dropdown having input, output, and both), then READ [ v] FROM () where the dropdown would have character, number, line, and all (and possibly s-expression). Also PEEK CHAR FROM (), and STREAM () AT EOF then for output, just WRITE () TO ()  that would accept a number or a string and write it. There could also be a block for writing lists as s-expressions. There would also be two constants, STANDARD INPUT and STANDARD OUTPUT (ore possibly a single constant that can be read to and written from. There could also possibly be socket streams too, for connection to/implementation of servers.

Finally, there could also be MAKE CUSTOM STREAM INPUT () OUTPUT () EOF PREDICATE () which takes 3 inputs: an procedure that takes no inputs and reports a character for input, a procedure that takes one input and writes it for output reporting nothing, and a predicate that takes no inputs and returns true or false depending on whether the stream as at the eof or not. All of these inputs can also be the empty ring to indicate "this feature is not supported." This could be used for implementing string-streams, pipes, and stream plumbing.

Hardmath123 wrote:

Yeah, totally! 

bharvey, when I said efficient, I didn't mean execution time (which I really don't care about too much). I meant the amount of time and code it takes to do something. For example, just to take a list and replace each item with its factorial, here's what I'd do in Obj-C, JS and Python:

Code:

-(NSInteger) factorialOf:(NSInteger)n {
    if (n==0) {
        return 1;
    } else {
        return [self factorialOf:(n-1)]*n;
    }
}
-(void) main {
    NSString * contents = [NSArray arrayWithContentsOfFile:@"/path.txt" encoding:NSUTF8Encoding error:NSError];
    NSMutableArray *items = [NSMutableArray arrayWithArray:[contents componentsSeparatedByString:@"\n"]];
    for (int i=0; i<[items length]; i++) {
        [items replaceObjectAtIndex:i withObject:[self factorialOf:[items objectAtIndex:i]]];
    }
    [[items componentsJoinedByString:@"\n"] writeToFile:@"/path.txt" atomically:YES];
}

Code:

def factorialOf(n):
    return 1 if n==0 else factorialOf(n-1)*n

f = open("/path.txt","w+")
contents = f.readLines()
contents = map(factorialOf,contents)
f.write("\n".join(contents))

See the difference? I had to refer to like 3 class references for Obj-C, while the Python is off the top of my head. My language would ideally simplify this even more.

@nXIII I think I'll call it "PyScheme".  Which begs for the motto "I scream, you scream, we all scream for PyScheme!". 

If you want a succint program, this is Haskell:

factorial n = product [1..n]

OldCodger wrote:

Hardmath123 wrote:

Yeah, totally! 

bharvey, when I said efficient, I didn't mean execution time (which I really don't care about too much). I meant the amount of time and code it takes to do something. For example, just to take a list and replace each item with its factorial, here's what I'd do in Obj-C, JS and Python:

Code:

-(NSInteger) factorialOf:(NSInteger)n {
    if (n==0) {
        return 1;
    } else {
        return [self factorialOf:(n-1)]*n;
    }
}
-(void) main {
    NSString * contents = [NSArray arrayWithContentsOfFile:@"/path.txt" encoding:NSUTF8Encoding error:NSError];
    NSMutableArray *items = [NSMutableArray arrayWithArray:[contents componentsSeparatedByString:@"\n"]];
    for (int i=0; i<[items length]; i++) {
        [items replaceObjectAtIndex:i withObject:[self factorialOf:[items objectAtIndex:i]]];
    }
    [[items componentsJoinedByString:@"\n"] writeToFile:@"/path.txt" atomically:YES];
}

Code:

def factorialOf(n):
    return 1 if n==0 else factorialOf(n-1)*n

f = open("/path.txt","w+")
contents = f.readLines()
contents = map(factorialOf,contents)
f.write("\n".join(contents))

See the difference? I had to refer to like 3 class references for Obj-C, while the Python is off the top of my head. My language would ideally simplify this even more.

@nXIII I think I'll call it "PyScheme".  Which begs for the motto "I scream, you scream, we all scream for PyScheme!". 

If you want a succinct program, this is Haskell:

factorial n = product [1..n]

to generate a list of factorials:

factorial n = scanl (*) 1 [1..n]

factorial n = product [1..n]

factorial := n\(1..n) product

: factorial ( n -- n ) [1,b] product ;

Hmpf.  If we're having a competition for fewest keystrokes, there's no competition for APL:

×/ιN

PS: It's been a long time, but iirc this works unmodified if N is a list of numbers.

PPS: At one point, Jens and I were discussing APLifying the BYOB operators (i.e., extending their domain to arbitrary-dimension arrays of numbers).  We never exactly rejected the idea, but we never followed through on it either.

P^3S: According to http://tryapl.org my first PS is wrong.  For a list, I had to say

×/″ι″N

There's probably an easier way that I've forgotten.

P^4S:  There's also a built-in ! operator, but I thought that would be cheating.  But it does work on lists without help.

Last edited by bharvey (2013-01-29 00:16:22)