I could not possibly agree more with this view of teaching software/CS.
We are focused on introductory programming education at a high-school and collegiate level — what is often called “CS 1” and “CS 2” (roughly, the first year of college). Pyret is being actively used in everything from high-schools to upper-level collegiate courses, giving us a tight feedback loop.
Of course, even in that setting there are differences of opinion about what needs to be taught. Some believe inheritance is so important it should be taught early in the first semester. We utterly reject this belief (as someone once wisely said, “object-oriented programming does not scale down”: what is the point of teaching classes and inheritance when students have not yet done anything interesting enough to encapsulate or inherit from?). Some have gone so far as to start teaching with Turing Machines. Unsurprisingly, we reject this view as well.
What we do not take a dogmatic stance on is exactly how early state and types should be introduced. Pyret has the usual stateful operations. We discussed this at some length, but eventually decided an introduction to programming must teach state. Pyret also has optional annotations, so different instructors can, depending on their preference, introduce types at different times.
I’m delighted to see work on languages like Dr. Racket and Pyret, and the more so because the teams behind both have been willing to set aside many of the dogmas of how CS has been taught and actually do pedagogical research. Also: OOP is a useful tool, but I’m with them: treating inheritance as a first-semester concept is… nutty.
The whole “Why Pyret?” page is worth reading if you have any interest in programming languages or teaching software development and computer science.
Growing a Language, by Guy Steele is without competition the single best technical talk I have ever seen.
This is a great summary of what I enjoy about Rust: it just lets me get stuff done—quickly, usually elegantly, and it’s always speedy:
— nrc (@nick_r_cameron) December 30, 2016
A thing I just learned:
cargo doc --open: full, local docs for every dependency your Rust crate has.
Spent a chunk of the afternoon figuring out how to implement Rust’s
Result type in TypeScript. Pretty cool!
While watching a theology lecture for school, I may have also spent some time learning how to do newtypes in Elm.
Using ML-style types to reason through things—even just as a reasoning tool, without language support—makes such a huge difference.
I’m rewriting a hairy, often-buggy section of HolyBible.com’s user logic, and using type definitions for reasoning was invaluable.
My #firstsevenlanguages—looking strictly at what I’d used at all; ignoring HTML and CSS):
In terms of what I learned well enough to use, though:
I signed a contract today for a neat little writing project broadly related to my ongoing Rust and Swift series. Probably means a bit of a hiatus on the series itself, but there’s a lot of fun ahead. More on that as it develops.
I’m quickly discovering a desire for actual, enforceable types as I’m trying to compose a series of functions. It’s hard without them.
The more time I spend looking at F♯, the more I like almost everything about it. The only pain point… is that Microsoft foolishly choose to PascalCaseAllTheThings. 🙄
Things I did tonight:
The first thing I do when I start playing with a new language/framework/etc. (like I just did with Elm) is download the Dash docset for it. The time it saves is extraordinary.
So I love the Rust compiler (and it’s improving all the time). But the Elm compiler is a revelation. Just… wow.
We’re sitting here with a friend, talking about two’s complement representation of negative numbers in binary. We are nerds, people.
Here I am, at the end of the week off, and what am I doing? Writing a Rust RFC. Yep.
I needed to write a tiny server to test out some quirky single-page app stuff I’m doing for Olo right now. So I did it with Python and Flask.
Finally at a spot where I have both the time and the mental energy to pick back up my Rust and Swift series. Initializers, I’m coming for you.
Just bumped into another person who (quite reasonably) didn’t know that ES6
classes are just syntactic sugar for prototypes. I like classes… but they’re more confusing than not, I think.
Wrote the first draft of my RustConf 2016 proposal. Because I don’t skip chances to chat about Rust. Not ever. You know that by now.
This blog post on recent compiler work in Rust is incredible: great work, and great technical writing. 💙 Rust.
Basically: an ML, I guess.
I 💙 the Rust team. So much.
I was reading some C++ yesterday, and I can’t put my finger on what it is about the language, but I just find it unbearably ugly. Rust’s syntax isn’t that different, but I don’t have the same visceral reaction. I wonder why that is?
I posted these as a series of tweets.
Fired up and played the demo for Elite Dangerous on my Parallels VM. Made me want to buy it. But of course, I’d prefer to play it natively.
Of course, it’s available for Mac. But my (more than a decade old) joystick doesn’t have any support on OS X. No drivers, full stop.
You can find software out there which recognizes it, of course—but it’s quirky and doesn’t behave well.
Looks like opportunity calling.
I might—might, I say, not will—end up seeing if I can write the requisite pieces in Rust. Because that seems like a good plan.
Spent the last little bit reading about Rust’s type system for the next episode of New Rustacean. Heady stuff.
This is interesting: I’ve read some F♯ before, but it reads a lot more obviously to me now that I’ve read a lot of Rust recently. Why? Because for all that they’re very different languages, both are ML descendants. It shows.
I’m writing a bunch of C that needs to handle error returns. I’m really wishing I had Rust’s
#[must_use] annotation right now. For that matter, I just want Rust’s
Result<T, E> type available.
Tonight, Jaimie said that she thought Rust had turned me into a bit of a fanboy. Don’t tell anyone, but I think she’s basically right…