Bar():int =
if (Foo[]):
1
else:
2
Find(X:[]int, F(:int)<decides>:void)<decides>:int =
for (Y:X, F(Y)):
return Y
false? Bar():int =
if (Foo[]):
1
else:
2
Find(X:[]int, F(:int)<decides>:void)<decides>:int =
for (Y:X, F(Y)):
return Y
false?Well, the opposite of that approach gives you Go.
I think Redstone in Minecraft are good examples of introduction to programming via visual programming languages. Something you can really feel and play around with. I'm not sure how Verse or Lua are integrated into their respective games but it's really hard to imagine kids being able to get into these languages without something that gives immediate visual feedback
Anecdotal, yes, but based on how popular Roblox has become, I would guess that its a fine enough intro language for even the next generation of software engineers
I think in some ways we have become too afraid of some upfront complexity at the expense of beginners in order for more well engineered systems. I think a slightly higher learning curve is not always a bad thing.
we should strive to provide a better gateway than we had when we were young.
In general, lowering the entry barrier is good. But you are right that we may now be scared of anything that doesn't have a very low entry barrier.
I don't think so. TFA notes that Verse was created to support a non-trivial use case, which is to make it possible to write software that works across multiple servers in order to support thousands of simultaneous players.
https://dev.epicgames.com/documentation/en-us/uefn/verse-lan...
AFAIK at present time there’s no way of even using Verse outside of Fortnite mods.
It certainly seems that it’s best suited for the use case you described, but their site is trying to sell it as a “let’s all learn programming and mod Fortnite” thing.
And certainly I think they pulled it off. Go through the lessons here to see what I mean in nothing stands out as beginner unfriendly here, but it's also not black boxing much in the way Python would. https://dev.epicgames.com/documentation/en-us/uefn/learn-the...
For such a core pillar they are extremely light on details. All you can see in the docs is they basically have:
- green threads (maybe? no idea, no details on how async is executed)
- "async calls" are blocking. Literally the equivalent of `x = await y()`
- to have non-blocking calls you can use `Task = spawn(function)`, and then can optionally wait on it with `Task.await()`
- there are a few syntax sugars on top (like `race` aka `Promise.race`). And some of them make no sense (`branch` is literally `spawn`, why does it even exist?)
That... is not a "core pillar". It's a lazy minimal bare-bones implementation of decades-old ideas.
Edit. Compare with a language where it actually is a core pillar: https://erlang.org/download/armstrong_thesis_2003.pdf
Well, they have also inverted the usual capitalization conventions for seemingly no reason. Class names are lowercase_with_underscores and local variable names are UpperCamelCase.
aka snake_case
> UpperCamelCase
aka PascalCase
But yeah I agree it’s curious that they use these the other way around from what I am used to in Python and Rust.
PascalCase for variables reminds me of unification-based programming languages like Prolog.
It's a really neat LISP. Yes, a LISP.
to factorial :number
if :number = 1 [output 1]
output :number * factorial :number - 1
end
or... to reverse :stuff
ifelse equal? count :stuff 1
[output first :stuff]
[output sentence reverse butfirst :stuff first :stuff]
end
From https://el.media.mit.edu/logo-foundation/what_is_logo/logo_p...And from https://dl.acm.org/doi/pdf/10.1145/3386329
Logo’s design drew upon two theoretical frameworks: Jean Piaget’s constructivism and Marvin Minsky’s artificial intelligence research at MIT. One of Logo’s foundational ideas was that children should have a powerful programming environment. Early Lisp served as a model with its symbolic computation, recursive functions, operations on linked lists, and dynamic scoping of variables.
....
In LCSI Logo, the if instruction above becomes a call to the if procedure, which takes three inputs:
if :x<0 [right 90] [left 90]
The first input is a Boolean value, reported by the < procedure. The second and third inputs are instruction lists, only one of which will be evaluated by if depending on the value of the first input. Square brackets both delimit and quote a list, so [right 90] is equivalent to ’(right 90) in Lisp. The entire expression is therefore equivalent to (if (< x 0) ’(right 90) ’(left 90))
in Lisp notation. How can Logo represent a thunk as merely the text of its body, without wrapping it in a lambda expression to capture its closure? See Dynamic Scope below (Section 3.7).The use of quoted instruction lists didn’t start with LCSI. From the beginning, the main looping facility has been
repeat 4 [forward 100 right 90]
with the instructions to be repeated inside square brackets.----
LOGO was secretly introducing us to lambdas and thunks and closures... back in 3rd grade on the Apple][+.
One of my laments is "I wish that we had computer scientists teaching us LOGO back then rather than the librarian who just wanted some quiet while we played Oregon Trail."
So... the weird characters? We dealt with them as kids, that's no weirder than LOGO.
> So... the weird characters? We dealt with them as kids, that's no weirder than LOGO.
Most kids didn't learn much from LOGO. AIUI the best available research on learning programming (which is very limited) says that weird characters are a barrier to understanding, and so is case sensitivity.
> The first four years of Logo research, development and teaching work was done at BBN. The first implementation of Logo, called Ghost, was written in LISP on a PDP-1. The goal was to create a mathematical land where children could play with words and sentences. Modeled on LISP, the design goals of Logo included accessible power and informative error messages.
> Logo was a primary influence on the Smalltalk programming language. It is also the main influence on the Etoys educational programming environment and language, which is essentially a Logo variant written in Squeak (itself a variant of Smalltalk)
http://worrydream.com/EarlyHistoryOfSmalltalk/ for more on how LOGO influenced Smalltalk design.
I am saying that LOGO is old. It was written the same year that BCPL (the predecessor for C) was written. To say that LOGO is a member of {language family}, it should be restricted to languages that were in use at that time.
LOGO is a member of the LISP language family. From there, it also went on to influence many other influential languages.
For my money, we'd actually be better off if kids were still learning BASIC, for all its faults. I don't know Lua too well, but maybe that's best in breed. Don't even get me started on Python >:(.
One of the tensions is "make it learner-friendly" vs "align it with languages they're likely to use as professionals", aka "don't teach bad habits", but IMO this is grossly inflated as an issue because (a) many of these kids will not become programmers anyway, (b) they certainly won't if their learner languages put them right off by being full of counter-intuitive gubbins, and (c) the idea that learning BASIC, or Cobol, or whatever, fundamentally ruins your brain for "proper" programming is a manifest nonsense anyway.
More important question is if a language has a spec or just a default implementation, and if so if that's a compiler, interpreter, JIT etc.