bharvey wrote:
Hot off the presses: a Greek translation by
Nektarios Moumoutzis. Download it and add it to the locale folder.
That's all Greek to me.
Actually, I'm not downloading it, because I only have like 6GB left on my C: drive ( ), so I'm trying to clear up unneeded stuff, not add unneeded stuff. ^^
Offline
scimonster wrote:
Actually, I'm not downloading it, because I only have like 6GB left on my C: drive ( ), so I'm trying to clear up unneeded stuff, not add unneeded stuff. ^^
Try having only 5GB left on your C: and 4GB on your F:
OFF TOPIC:
Is it against Berkeley's policy to allow you to put a donation button on the BYOB site?
Last edited by 14God (2011-06-01 12:25:23)
Offline
14God wrote:
OFF TOPIC:
Is it against Berkeley's policy to allow you to put a donation button on the BYOB site?
That's more on topic than how much disk space you have!
We could probably accept donations to the university on the web site, and (if we had the technology set up) even direct them to our project. We'd have to get several thousand dollars to do anything really useful with the money (namely, hire an undergraduate, or maybe buy Jens an airplane ticket).
We couldn't just pocket the money, though.
All in all, I think the small amount of money involved wouldn't be worth the possibility of someone seeing it as a barrier to using BYOB (e.g., because they wouldn't want to see their students feel under pressure to contribute).
Maybe someday you can take me and/or Jens out to dinner.
P.S. You young whippersnappers who think 4Gb isn't much disk space don't know how lucky you are! Why, when I was your age we had to read the bits on the disk with a magnifying glass!
Last edited by bharvey (2011-06-01 16:40:34)
Offline
itsme213 wrote:
When I click the 3.1.1 link (Mac) I get
Server not found
Firefox can't find the server at byob.berkekey.edu.
Should work. Maybe it was a temporary server failure?
EDIT: Wait, did it really say "berkekey" or did you transcribe it by hand?
Last edited by bharvey (2011-06-05 22:32:03)
Offline
bharvey wrote:
Maybe someday you can take me and/or Jens out to dinner.
Unlikely, I'm not much for traveling. Not to say that I'm a Scrooge or a Hermit I would definitely work for you guys (for free) if I knew Java script, which I don't... for now.
Offline
14God wrote:
BUMB, we aren't on the front page!
Offline
14God wrote:
whats the progress on Snap?
Umm. Jens is working on the GUI part, and, being Jens, will be finished first. Fullmoon and nXIII are working on implementing the primitive blocks. I have a team of four Berkeley students working on the evaluator -- probably too many, because I didn't get any progress reports while I was in Boston. I'll try to get on top of that now that I'm home and finally unpacked.
Btw, I had interesting discussions with members of the S.T. while I was there. No big news on Scratch 2.0; right now they're mostly focused on the Web aspects of the project rather than on new features of the language. But, thinking ahead, they're interested in capturing the new AP CS Principles audience, just as we are, and that might encourage them to raise the ceiling somewhat down the road. NO PROMISES, but I think I made a convincing case that custom reporters and first class lists are the very least anyone would need to decide to teach the course entirely in Scratch. They didn't promise anything; as always, they're very cautious about making sure the design of new features will fit in well with their original goals. But they didn't seem to have strong objections about those two things. First class procedures and sprite inheritance were much harder sells! Those definitely open big cans of worms; I couldn't really argue that people who didn't want to use those features wouldn't notice them. OTOH, I'm hoping a year from now to have hard data about how well high school students learn to use first class procedures, and if the trials go well, I'll have more convincing arguments to make in next year's summit meeting. I had a long talk with John M. about the technical details of inheritance in BYOB. (For example, our version relies on first class blocks, and we talked about how it might be done without that, which would arguably make inheritance more understandable to beginners even if you do have lambda also.) I also made a pitch for some of the less central UI improvements (imho) in BYOB, such as zebra coloring. So, who knows, maybe some of those will find their way into Scratch 2.1 or 2.2 eventually.
Offline
I don't understand 1/4 of BYOB. I somewhat agree with the ST about this.
Offline
bharvey wrote:
scimonster wrote:
MathWizz wrote:
The links are broken.
BYOB site is down.
It works for me. If you guys are still having trouble, could you send me a screenshot or a more detailed report on what happens when you try it?
Offline
scimonster wrote:
I don't understand 1/4 of BYOB. I somewhat agree with the ST about this.
Well, let me break this into two pieces.
1. About agreeing with the ST: We've never claimed that every Scratcher will understand lambda instantly. Rather, what we think is that not understanding lambda isn't going to scare people off, and isn't going to interfere with their use/enjoyment of the rest of Scratch (supposing lambda were in Scratch). People have always not understood some of Scratch: "How do you scroll the background?" "What is BROADCAST AND WAIT for?" "How come the cat turns upside down when it hits the wall?" And, like those other examples, we think lambda is something Scratchers can grow into with more experience. But unlike those other examples, lambda may be something many people don't grow into until they're college age. So, that might be a reason for the S.T. to think it doesn't pay off to add lambda.
On the other hand, I've seen a handful of kids just get it instantly, without any teaching, as soon as they see something like a list of blocks on the stage. The youngest kid to whom I've successfully taught lambda was in fifth grade (and that was in Logo, not even in BYOB). Let's say that in this round of curriculum testing next year we have 300 high school kids involved, most from low-income school districts, and let's say half of them really learn the idea well (by which I mean, I guess, well enough to use higher order functions in their final programming project). That wouldn't be a total success, but if half of all high school kids can get it, and see the beauty in it, and if it encourages their interest in computer science, wouldn't it be wrong to withhold it from them? It's not a technology like cars or guns, which can kill people! It's more like musical instruments, which only a minority of students will learn to use skillfully, but to which we nevertheless want to expose every kid, so that the ones who will be good musicians get a chance to learn that about themselves.
If in the trial next year, 10% of the kids understand it, and the other 90% get frustrated and decide not to be computer scientists, then I guess I'll have to agree with the S.T. about it. (But then we'll still need a separate version of the language to use with our undergraduates, who do get lambda.)
2. To help my own understanding of the issues above, as well as for your sake, I'd like to try to get you to understand all of BYOB, if you're interested. For starters, have you watched the tutorial projects? If so, where did you get lost? Thanks!
Offline
henley wrote:
(screenshot)
Oh! You have an old link. It's http://byob.berkeley.edu/BYOB_3_1_1_110 … hanges.zip for the latest version. Where did you find the link you clicked?
Thanks for posting the screenshot!
Last edited by bharvey (2011-06-09 11:28:40)
Offline
bharvey wrote:
But unlike those other examples, lambda may be something many people don't grow into until they're college age. So, that might be a reason for the S.T. to think it doesn't pay off to add lambda.
I'm in 9th grade and I started using BYOB last year. I understood lambda pretty much right off that bat and just needed some help understanding the GUI from the tutorial videos, I also watched your higher order functions tutorial which made perfect sense. I think recursion is in a sense far more difficult to learn because it is harder to mentally track. The advanced features In BYOB never scared me off even before I understood all of them because I was compelled by stuff I wanted to do with those features. I think If their is something a kid wants to make he will be willing to adapt to all sorts of new features to do that. Maybe you should introduce kids using Scratch and have them work on (fun) projects that you know will be almost impossible without BYOBs features then show then BYOB and they will instantly fall in love with all its feature because they are exactly what they need.
Offline
14God wrote:
I think recursion is in a sense far more difficult to learn because it is harder to mentally track.
That's really what I think, too, but pretty much every CS teacher in the world seems to disagree with me. But it's complicated because in other languages there are really three levels of understanding HOFs involved and BYOB sort of mixes up the first two:
1. Being able to use prebuilt higher order functions (e.g., MAP) with named functions as input. So, in Scheme, something like
(map square '(7 8 1) ) ==> (49 64 1)
2. Being able to use prebuilt HOFs with functions created on the fly using lambda:
(map (lambda (x) (+ x 3) ) '(7 8 1) ) ==> (10 11 4)
3. Being able to write your own HOF.
I haven't ever really thought this through before in quite this way (so, take note, please, Jens, and tell me what you think about it), but the whole grey-bordered-input notation that people seem to find confusing is kind of my attempt to have something at that first level of understanding, so you could use MAP without using THE BLOCK explicitly. Level 2 is where THE BLOCK (our version of lambda) should come in, but in BYOB, unlike Scratch, there's really no such thing as "the name of a block" distinct from the block itself. If you make a SQUARE block, you still have to say THE [SQUARE ()] BLOCK or the grey-border equivalent to use it as input to a HOF.
It matters because level 1 is the thing that I think anyone could understand easily, but the drawback of a visual language is that we don't really have a level 1. A long time ago I tried to talk Jens into making the grey border come before the white halo as you move toward a procedure-type input slot, but for reasons I don't understand it was too hard to do it that way. I think that would help move grey borders toward being a level 1.
But meanwhile, people essentially have to start at level 2, and I think that makes the whole business seem more arcane than necessary.
Thanks for prodding me into thinking this out!
... have them work on (fun) projects that you know will be almost impossible without BYOBs features
You're a Trotskyite! You've just reinvented the "transitional demand." (Look it up in Wikipedia.)
Offline
I don't understand recursion.
Offline
scimonster wrote:
I don't understand recursion.
Taneb wrote:
Funnily enough, I find recursion easy, but have no idea what this lambda stuff is about.
Hmm. Well, I'm glad we narrowed it down.
I'm in the middle of writing a proposal so it may be the weekend before I reply to these. Meanwhile, it would help me if you went through the slides in Tutorial 3 (scimonster) and Tutorials 1 and/or 2 (Taneb) and tell me more precisely where you get lost.
I'm hoping that we can pin down the points of difficulty and improve the tutorials and/or the software to clarify these ideas. Thanks!
Offline
scimonster wrote:
I don't understand recursion.
Preface: In my computer science books I explain recursion three times, three different ways, because different people seem to respond better to different ways. So if you read the following and it doesn't help, please don't give up. But do tell me which step loses you.
1. The definition of recursion: A procedure calling itself inside its definition. In BYOB terms, that means a block whose script (in the Block Editor) includes the block itself.
2. The purpose of recursion is to help solve the kind of problem that includes a simpler version of the same problem within it. The canonical example is drawing a tree:
Do you see that (a) the whole thing is a tree, and (b) the red part is also a tree and the orange part is also a tree? That's an example of a "problem that includes a simpler version of the same problem within it."
3. So we're hoping that the script for TREE will be something like this:
draw the trunk (the blue vertical)
turn left
TREE
turn right
TREE
4. That pseudo-script actually almost works, except for two things. The first is that, if you think about the steps in that script, it's assuming that after the first call to TREE (the one that draws the red smaller tree), the sprite is back at the bottom of the red tree, not up in the leaves somewhere. So we have to add two lines to the script to ensure that that's the case:
turn left (back to the starting direction)
move back down the trunk
5. The second problem with this script is that, as it stands, it'll keep trying to draw smaller and smaller left branches forever, so it'll never actually draw a right branch! To fix this problem, we need a way to measure the complexity of the problem -- or, in this case, the depth of the tree, which is the number of line segments from a leaf down to the bottom of the (entire) tree. So, the tree in the picture has depth 5; the red and orange trees each have depth 4.
A depth-1 tree is just its trunk. So:
6. A depth-2 tree includes two depth-1 trees:
7. Once you see how to write TREE2, you could write TREE3 using it, and rhen write TREE4 using TREE3, etc.
8. Instead of including the depth as part of the name of the block, we could have a single TREE block that has an input named DEPTH. But (see point 5 above) we have to remember that a depth-1 tree is different from the others:
Okay, that's it for tonight. Are you still with me? Or, can you say where you don't follow the argument? Thanks.
Offline
I couldn't understand the Church numerals PDF either. I could understand the concept perferctly, but I couldn't see how the given blocks were supposed to work.
Offline
Taneb wrote:
I've watched the tutorials, and I think I understand them. But that church numerals PDF on the website is a brick wall.
rubiks_cube_guy238 wrote:
I couldn't understand the Church numerals PDF either. I could understand the concept perfectly, but I couldn't see how the given blocks were supposed to work.
Oh, is that all! If you understood the tutorials, you understand lambda. Now you're ready for advanced lambda!
So, in lambda calculus the game is to start with nothing but the ability to create procedures (THE BLOCK) and the ability to call procedures (CALL), and try to invent everything else.
(There's no reason why anyone would want to do arithmetic this way in practice; the use of it is in trying to prove theorems about computer programs. If we can prove that any computer program is equivalent to a lambda calculus program (and we can), then you can prove other things about lambda calculus programs and they're automatically true for any program. And having only two primitive blocks makes it easier to prove theorems than having all the different mechanisms of real programming languages.)
So in the Church numerals project, we want to represent the nonnegative integers in the form of lambda calculus functions. I think the easiest way to understand how Church did it is to imagine for a moment that besides THE BLOCK and CALL we have one other, ordinary function, let's say DOUBLE, which takes a number and returns 2 times that number. We can compose that function with itself:
DOUBLE(3) ==> 6
DOUBLE(DOUBLE(3) ) ==> 12
DOUBLE(DOUBLE(DOUBLE(3) ) ) ==> 24
and so on. So, we're going to represent the integer N with a function F_N that takes a function G as input (because, after all, functions are the only data type we have in this game!) and returns G composed with itself N times:
[F_3(DOUBLE)](3) ==> 24
because F_3(G) returns the function
H(x) = G(G(G(x) ) )
so F_3(DOUBLE) returns the function
H(x) = DOUBLE(DOUBLE(DOUBLE(x) ) )
So, F_0(anything) ==> the identity function h(x)=x,
and F_1(h) ==> h for any function h.
But we're not really going to define F_3 as in that picture, for two reasons. (1) There are too many integers for us to define each of them individually. (2) In this game we don't have MAKE A BLOCK either -- we can't give blocks names that way.
The handout actually cheats about point #2, because pure lambda calculus programs are way too complicated to read otherwise. But we're not going to cheat in the way that's important: We're not going to give a block a name so that it can call itself recursively. If we want recursion (and we do), we have to find a way for an unnamed block to call itself. But we're not ready for that yet.
If we want to make the function that I've called F_3 without using MAKE A BLOCK, it looks like this:
This is the structure that you have to understand. The outer THE BLOCK represents F_3 itself, and takes FUNCTION as input; the inner THE BLOCK represents the returned function H, which takes X as input. Every number will be represented this way: as a function of FUNCTION that returns a function of X.
But we're not actually going to construct F_3 by hand, even in this unnamed form. The only number we're going to construct explicitly is zero:
To get the positive integers, we're going to use the SUCCESSOR function, which takes a nonnegative integer (in this double-THE-BLOCK form) and returns the following integer (i.e., N+1). It does this by composing FUNCTION with the result of calling F_N on FUNCTION.
This works because, for example,
DOUBLE([F_3(DOUBLE)](3) ) ==> 48
which is the same as
[F_4(DOUBLE)](3)
So, SUCCESSOR is a function that takes an F_N as input and returns F_(N+1):
Whoa, three nested THE BLOCKs! I'm guessing this is about where your eyes glaze over. The outermost THE BLOCK is the SUCCESSOR function itself, which takes N (a Church numeral) as input. The two inner ones are needed because SUCCESSOR is supposed to return a Church numeral, and all Church numerals look like that -- a function of FUNCTION that returns a function of X.
If that all makes sense, try the project again. If not, see if you can ask a specific question about the point where you get stuck.
Offline
bharvey wrote:
scimonster wrote:
I don't understand recursion.
Preface: In my computer science books I explain recursion three times, three different ways, because different people seem to respond better to different ways. So if you read the following and it doesn't help, please don't give up. But do tell me which step loses you.
1. The definition of recursion: A procedure calling itself inside its definition. In BYOB terms, that means a block whose script (in the Block Editor) includes the block itself.
2. The purpose of recursion is to help solve the kind of problem that includes a simpler version of the same problem within it. The canonical example is drawing a tree:
http://byob.berkeley.edu/Tutorial3/simplecolors.gif
Do you see that (a) the whole thing is a tree, and (b) the red part is also a tree and the orange part is also a tree? That's an example of a "problem that includes a simpler version of the same problem within it."
3. So we're hoping that the script for TREE will be something like this:
draw the trunk (the blue vertical)
turn left
TREE
turn right
TREE
4. That pseudo-script actually almost works, except for two things. The first is that, if you think about the steps in that script, it's assuming that after the first call to TREE (the one that draws the red smaller tree), the sprite is back at the bottom of the red tree, not up in the leaves somewhere. So we have to add two lines to the script to ensure that that's the case:
turn left (back to the starting direction)
move back down the trunk
5. The second problem with this script is that, as it stands, it'll keep trying to draw smaller and smaller left branches forever, so it'll never actually draw a right branch! To fix this problem, we need a way to measure the complexity of the problem -- or, in this case, the depth of the tree, which is the number of line segments from a leaf down to the bottom of the (entire) tree. So, the tree in the picture has depth 5; the red and orange trees each have depth 4.
A depth-1 tree is just its trunk. So:
http://byob.berkeley.edu/Tutorial3/tree1pic.gif
6. A depth-2 tree includes two depth-1 trees:
http://byob.berkeley.edu/Tutorial3/tree2pic.gif
7. Once you see how to write TREE2, you could write TREE3 using it, and rhen write TREE4 using TREE3, etc.
8. Instead of including the depth as part of the name of the block, we could have a single TREE block that has an input named DEPTH. But (see point 5 above) we have to remember that a depth-1 tree is different from the others:
http://byob.berkeley.edu/Tutorial3/base1tree.BMP
Okay, that's it for tonight. Are you still with me? Or, can you say where you don't follow the argument? Thanks.
I got all that; the wiki explained it pretty well. LOL XD
Stuff like the MAP block is where I get lost, but that also uses lambada, which is in the same language as the most recent translation.
Offline