 A few years ago, I created an educational reporting language I call pigeon. And the core idea of pigeon was that semantically, it's a language that's stripped down, it's taking all the mainstream languages and distilling them down to their common elements. So you strip out all the conveniences, all the things in particular to one language over another. And what you're left with are you have functions, you have control flow with if and while and loop constructs, you have variables, you have operations, function calls, of course, and local variables and global variables. And that's about it. Aside from that, there's a question of whether you're going to be statically typed or dynamically typed. And for various reasons, I think dynamic typing is easier for a newcomer to simplify as a few things. And so pigeon is dynamically typed, and we have five basic data types, numbers, strings, bullions, lists, and maps. And that's it. Also, the language simplifies things by not having any kind of module system or packages or whatever you want to call them. So you just have a single source file of code for every program. You don't even have any kind of standard libraries. And so the only facility for input and output in this whole language is that there are two built-in operators. So there's the print operator and the prompt operator. So you can spit text out to console, and you can read text from console. But that's all you can do in this language input and output wise, which is fine for the context of a reductively simple educational language. Also for simplicity, unlike more conventional dynamic languages, like say a JavaScript or a Python, your top level definitions aren't ordered because they're not really executed statements, they're just things in no particular order, and execution kicks off with a function called main. So that's the language semantically, that's really all you need to know. And then syntactically, pigeon does three important things for the sake of learners. First off, it's indentation sensitive. And so like Python, we don't have curly braces or anything, you just from indentation, the language knows what's part of what what body is part of what statements and what function definitions, etc. Whether you prefer that in a real language or not, I think is beside the point for learners, it definitely is simpler. I see it a lot, learners really do get tripped up very early on with just deciding where to put their curly braces, getting weird error messages because they forgot to put one in, etc. It's kind of a pain. So it's just better to enforce indentation like Python. The second important thing, pigeon does syntactically is that all of the operations and function calls are in prefix notation. So you have a pair of parentheses, you have the name of the function or the name of the operator, and then you have all the operands or arguments separated by spaces, no commas. And be clear, this doesn't mean that this is a list dialect. In a list dialect, everything is an S expression, but we have a traditional statement based syntax, it's just that for our operations under function calls, those are in prefix notation. And the virtue of prefix notation was a couple of virtues. One is that there's no sense of order of precedence. Visually, it's entirely uniform. That's really important. You're not limited to just having one or two operands per operation. So you sidestep a lot of stuff that really is problematic for people right out of the gate. The third thing, the last thing that pigeon does that's very important syntax wise is all of the operator names are reserved words, not symbols. So for example, the arithmetic and operators are ADD for addition, SUB for subtraction, MUL for multiplication and DIV for division, MOD for modulus. This does make the code more verbose. But again, it's much more uniform for learners because this means that all of your operations look like function calls and vice versa. And it's driving home this commonality that they're both these expressions, these things that take input values and return output values, maybe with side effects, drive some of that commonality by making them look exactly the same. Generally, also, for like an operator that's totally new to you and has no analog to something you already know, it's much easier to remember a word, even an abbreviated word rather than an arbitrary symbol. So that's everything about pigeon, semantically and syntactically. It's something that can be taught to people who have no programming experience whatsoever. And while the mechanics can be explained in less than an hour, my video is like 45 minutes. And then beyond that, you would want to lead them through a few demos and a few exercises. And that's another say like four, five, six hours tops. So this this whole undertaking of learning this language can very, very easily be done in a day of instruction. And very importantly, in that day, you learn the entirety of the language, absolutely everything about it, which is not something you can say at all about any real language, even the ostensibly simpler ones, like there's dark corners lurking in really any real language, that's the problem with real languages. Let me give you just a quick example of pigeon code. Here's a program with a main function at the bottom, a function called sum with a parameter nums, notice parameters are not in parentheses, you just if you have parameters, there are extra names after the name of the function, which is a little weird at first, but that's important because it means the parentheses in this language consistently always mean exactly the same thing. You don't have the usual confusion of like, Oh, is that parentheses for, are they optionally there for controlling precedence? Is it there because this is a primary list or is it because there's an argument list of a function or, you know, all the different uses of parentheses and conventional syntax. So anyway, small detail there. We have a global variable called message at the top, it's being initialized to an empty string. Inside the sum function, all the local variables of your function are declared with a local statement at the top, this is two local variables total and I, we don't specify the time since the dynamic language as is an assignment statement. So we're signing here to the variable total, the value zero, by default, total had the value nil, now we'll have the value zero. And then a foreign clue, originally, I didn't have any convenience loops whatsoever. We just had while, but then that made code examples really verbose and ugly in a distracting way. And so I added in, instead of conventional for, we have a four H loop. But then we also have a thing I invented called foreign can four deck, where here this specifying this counter variable I, it's initialized to Oh, geez, I have a mistake in the code. Let me correct this. There we go, I added in the zero. And with this foreign clue has a counter variable I that starts out with the value zero, and it is incremented each time to loop up to the value that is lend of nums. So once we reach lend of nums, that's when we break out a loop. So we'll go up to that value, but not including. And then in the body of the loop, we have an assignment to the variable total, taking the current value of total, adding it to the value at index I of nums, the way you access an element of arrays with the get operator. And so this code is going to accumulate in total the value of all the elements of nums. And then once we're through the loop, we print out a message, and we're going to return the value of total. That's what this function does. And then in the main function, we have a single local variable and we then assign to the global variable message, the string high world. And we call some, the list operator creates a list, in this case, with three initial elements five, three and eight in that order, we're passing that to some we get back the sum of five, three and eight. So that should be 16. And then we print out and which should be 16. So that's an example of pigeon code. If you know any mainstream language, you should have no trouble following that. If you're new to programming, don't worry, explain it in other videos. Now, however, there's a problem with pigeon, and that is that it's very simple and it introduces people very quickly to the core concepts of of programming or mainstream languages, at least without a lot of distractions stripping out those distractions. But the learner then wants to move on and learn a real programming language, but there's still quite this large gap between what they learned in pigeon and then what they need to learn in any real language, because again, there's all these dark corners in any real language, weird details, annoying distractions, which really does add up in itself, none of its rocket science, but these things add up and make them hard to learn. So ideally what we want is we want something that bridges the gap between what you learn in pigeon and then what you're going to learn in the real programming language you want to learn, whether that's JavaScript, Java, C, go, whatever. The problem is how you feel in that gap is going to differ based on what the language is. So I've already worked out a language which I call go pigeon, which is building on these semantics of pigeon, extending it with go semantics to teach you go. Because well, for various reasons, I think go is the best first real language that people should learn these days. It has some unique virtues. Number one, it's a relatively clean language compared to most anything out there. It's not a perfect language by any means, but relatively, it is simple. I like the documentation. It's easy to read, easy, I think for newcomers to understand. A lot of things about it are good for newcomers. And also it's uniquely setting people up for going in different directions. So if you learn go, and then you can next learn C and C++ and you've already to a great extent understood the concept of pointers if you learn go, even though it is a garbage collected language and you don't to point arithmetic and go, you're still you still have a leg up. I think it eases you into that that kind of programming. But then go also sets you up I think very well for learning the higher level languages, the web languages, if you want to call them that things like JavaScript and Java and Python, etc. So that's the first pigeon hybrid language which I created. And what that looks like is it's not everything semantically about go. It does have static typing type systems a bit simplified, we just have instant floats and bytes on sign integers of eight bits. But we don't have the other stuff because we don't, you know, we're trying to strip things down a bit. We do have multi return functions. We have structs, we have methods pointers, interfaces, type switch, which is not the term they're using go when so you have an interface and you want to switch over different cases of what the type is that so I go to type switch, you have a race and slices, you have function variables. And then I've added in file operators. So again, we still don't have any kind of module system, we don't have packages like in real go. But we want to be able to do something a bit more interesting. So I added in a few operators for opening reading and writing files, which is a little bit odd. Yes, but it gets the job done. It's a little strange, of course, to have that stuff in the form of operators, but it works. So here's that previous program translated over into go pigeon, what's different here primarily is now we have type information for variables, we have to specify the types after the name in the style of go. And then for our functions, we're also specifying types for the parameters and also what the return type is. So that's some function, for example, the nums parameter has type I as an integer, colon is the beginning of the return types. In this case, we're training just one kind of thing an integer, notice the local variable total also you have to specify its type and then also in our foreign loops and foredeck loops and for each loops, I also insist that you always specify the type even though in this case, I is always going to be an integer, but I make you write it anyway just for uniformity. And the last thing different here is down at the bottom, where we create a list of strings. Oops, that shouldn't be a list of strings. I have another mistake in my code. Let me fix that. There we go. I corrected this. It was a list of strings, but now it says it's a list of integers. So unlike a dynamic pigeon, because we have different types of lists and arrays and slices and all those sorts of things, we have to parameterize them. And this is the syntax for parameterizing them. You have ankle brackets after the core type, which is list. And this is a list of integers. And then we specify these values integer values five, three, eight. Anyway, so that's a quick and dirty example. There's quite a bit we actually leave out a lot of details, the full set of base types. Of course, the syntax is different. We don't have any inferred typing, no colon equals syntax, no subscoping in your functions. Your function is just one single scope. So all your variables get declared at the top of the look in a local statement, as I call it, no go routines or channels, I did have those in originally, and also had nested functions, enclosures and method values and method expressions. I was trying to be more complete originally. And I actually implemented that stuff. The issue wasn't that the mechanisms themselves are all that complicated. It's more that I couldn't really in the context of very, very small demo programs, sufficiently demonstrate these features, like I could explain them and give you tiny little very, very artificial examples. But we couldn't go into any really practical stuff, because, you know, multi-threading concurrency gets immediately into a lot of complicated stuff. So best to save that for real go. And then for nested functions, enclosures, similar deal, the mechanisms not super complicated. It's a little weird conceptually perhaps, but it's not complicated really. But again, I couldn't really probably justify it in the context of tiny programs that are never going to be more than like a few hundred lines. So I dropped that stuff from the language. And then we don't have, well, we do have panics in the sense that certain operations give you an error, but we don't have any means to recover from them. We don't have defer either. We don't have variadic functions or return parameters. Those are mostly stylistic niceties we don't really need. We don't have structed interface embedding, const iota, go to our labels. Nobody we have bitwise operators or compound assignment operators. And again, we don't have packages. So of course, we don't have the go standard library. So you learn go pigeon, it takes another. Well, once you already know pigeon learning go pigeon, probably just another hour, at least in terms of explaining the mechanics. But actually demonstrating them and going through exercises, you could spend a bit more time because you can do a bit more substantial stuff in this language, because we can work with files. So let's say it's like two days of material. And then after those two days, you should learn the real go. And at first, that's mostly just amount of translating one to one into the different style of syntax. But then, of course, you'll have to cover go routines, channels and nested functions and closures and a few other odds and ends. So go pigeon doesn't do all of the heavy lifting, but it does a lot of it. Here's what currently the GitHub project page for pigeon looks like. There's some instructions on installation usage, there's not much to know there. And there's some reference information here, you might want to look at some notes. I'm still working on this stuff. It's work in progress. And I also have some videos which I'll put links to on this page as well. Once I put them up, just to understand that at the time of making this video, at least there's some odds and ends I'm still working on. And in general, the whole thing needs more testing. I didn't do any kind of formal testing on this project, probably should have. It's a pretty good candidate for that. But I didn't also should work on better error messages, error messages that are there aren't terrible. But they can always be better. That's very important, particularly for learners language. I'm going to add in at some point, a debug statement. I didn't have a weird debug system already where you can actually set break points. But I stripped that whole thing out, but I'll add it back in where you actually put a debug statement where you want to have a break. I'm considering adding in a special get and set syntax. I'll have to think about that one. The real motivation there is not because I think go pigeon really needs it, but because I'm also working on C pigeon and JS pigeon and I'm thinking about doing Java pigeon. And in those languages, particularly JS pigeon, you do a lot of get operations in your JavaScript code, something about adding in some special syntax. And if I do it in that language, I want to make it uniform across the different pigeon dialects. The videos as I have them are currently just a rough draft. You'll notice that because I was making them as I was developing the language, there are some things that just outright changed. So if there's some discrepancy in what you see in the videos, just know that what's in the on the GitHub page in the references, that's the authoritative version of the language as it currently stands. So it's not huge things, but just some little minor things. And the last big missing piece and probably actually really the most important is I just needed to develop more demos and exercises to walk people through once I teach the language. I have some stuff, but it's always good to have more of those. So if you're programmer and you teach programming or just interested in programming education and you'd like to contribute in some way, you can make comments to me on Twitter, or you can go to the GitHub page and leave some some messages there. And if you're a student, likewise, first place that would look is on Twitter, also the YouTube videos, you can leave comments there as well.