Introductions to programming suck
-
Half-disagree. Within reason, language doesn't matter. It just shifts the leven of effect. An important motivation is the ability to change the world, and that's very tedious in assembly. There might be an easy way out: use assembly to control hardware - that's somethign fascinating to many programmers even after decades of doing that. There's another problem, though: The guys doing assembly. I would not want to let any of them near any budding coder pubs.
There are general problems with training programmers: The Architect teaches the mason, the biologist the butcher. There is a huge rift between Comp-Sci and Comp-Do, but they are treated as a continuum. Ideally, we make comp-sci bother more with what matters in practice, and comp-do more open to the teachings of comp-sci1. Unless we achieve that, we may need to clearly separate education for the two. There's no recipe for building software. The industry is immensely dependent on those that "get it", that have - or develop - the knack for making software. HR is unable to tell those apart from those who can't. We are unable to teach how to make software, since we rely a lot on witchcraft and snake oil ourselves.
So I would start off with: Some turtle-graphics-like[^] language very early, just to plant the seed. A mid-abstract, imperative language, to teach the grunt work, and to motivate for planning, miantenance, and further abstraction. A secondary, significantly different language, could even be logic or functional. 1) And it's not entirely comp-sci's fault. We've become very effective at ignoring knowledge that is already availabe for decades, and rather follow the newest fad. Because we are oh so special.
I guess you'll like this: On a cultural gap[^] by Edsger W. Dijkstra
Espen Harlinn Principal Architect, Software - Goodtech Projects & Services AS Whenever methodologies become productized, objectivity is removed from the equation. -- Mike Myatt
-
Brings back fond memories of teaching CS101 to freshmen in 1984. In my first lecture, I made the students parts of a human computer - each got an instruction (which they weren't supposed to share with others) and we laboriously walked through a
forloop that counted from 1 to 10. Took close to an hour to get the "program" to finish. I then asked them how long they thought it would take on a mainframe. Responses ranged from "less than a second" to "1 second". I upped the ante and asked what if the loop ran to a 100? A thousand? Ten thousand? Responses were mixed, but nobody was ready for the app to finish running in a few seconds. They were completely blown away. (Learning experience #1: computers are FAST). Next, I made the human computer subtract the index instead of counting up, causing an infinite loop. The kids saw the error right away. We then programmed the mainframe (a VAX-11/780) to do the same thing. Whoops! Infinite loop! (Learning experience #2: computers are STUPID). We didn't write code until week 2. By then, 2 interesting things occured: (1) many students dropped the course and (2) almost all of those who stayed on loved it and got nothing less than a B. It was one of the best experiences of my brief (3 year) teaching career and I was happy to receive an award for being one of the best undergrad instructors at NYIT. :) /raviMy new year resolution: 2048 x 1536 Home | Articles | My .NET bits | Freeware ravib(at)ravib(dot)com
I would have enjoyed taking classes from you, Ravi!
Software Zen:
delete this; -
I've seen tons of people utterly fail to grasp the introduction to programming, and to be honest, I don't really blame them. Many failed to grasp not the syntax of whatever arbitrary language the teachers decided to throw at them (often C++, Java or C#), but the core idea of programming: you're giving the computer a list of instructions that it blindly executes. So I blame the choice of language. The languages commonly used to introduce CS students to programming do not make it obvious what programming actually is, to the beginner it all looks like magic. Especially when OOP is added - without building it on top of something (the way it's usually taught is out of the blue and with flawed real life analogies), that's just pure magic. People who might (I think) otherwise have become decent programmers if they had been taught differently get stuck behind the hurdle of figuring out the core concept for themselves (while getting bogged down in abstract concepts that aren't useful at that stage yet), and give up. IMO a simple assembly language would make a much better first language. It makes the core concept explicit. It's conceptually simple. No confusing abstractions. The syntax is trivial. It really is as simple as a list of instructions. The only problem with assembly (hard-to-manage growth of complexity as projects get bigger) is irrelevant in this situation - you're only going to give assignments for simple straight line code at first, then some conditionals and loops, subroutines if you're brave, nothing unwieldy. ps: I learned z80 assembly as a first programming language so I might be biased.
My first programming class was in FORTRAN and the second was in IBM 360 assembly language. In retrospect the 360 was an odd beast, but it still gave you an appreciation of the 'nuts and bolts' underlying everything. Shortly after that I got a part-time job working as a programmer. I did a lot of work in microprocessor assembly language, and that drove the point home even further. My primary languages today are C# and C++, but I still try to appreciate everything going on underneath.
Software Zen:
delete this; -
I've seen tons of people utterly fail to grasp the introduction to programming, and to be honest, I don't really blame them. Many failed to grasp not the syntax of whatever arbitrary language the teachers decided to throw at them (often C++, Java or C#), but the core idea of programming: you're giving the computer a list of instructions that it blindly executes. So I blame the choice of language. The languages commonly used to introduce CS students to programming do not make it obvious what programming actually is, to the beginner it all looks like magic. Especially when OOP is added - without building it on top of something (the way it's usually taught is out of the blue and with flawed real life analogies), that's just pure magic. People who might (I think) otherwise have become decent programmers if they had been taught differently get stuck behind the hurdle of figuring out the core concept for themselves (while getting bogged down in abstract concepts that aren't useful at that stage yet), and give up. IMO a simple assembly language would make a much better first language. It makes the core concept explicit. It's conceptually simple. No confusing abstractions. The syntax is trivial. It really is as simple as a list of instructions. The only problem with assembly (hard-to-manage growth of complexity as projects get bigger) is irrelevant in this situation - you're only going to give assignments for simple straight line code at first, then some conditionals and loops, subroutines if you're brave, nothing unwieldy. ps: I learned z80 assembly as a first programming language so I might be biased.
I agree - for undergrads at least. But many schools teach some sort of programming too - and want to encourage students to select the courses at year 8 or 9 and so go for Gamemaker ans similar - which, frankly, frustrates those that want to program, and simply entertains those that want to play games. I learned 6502 as my first language - and it is an ideal learning language as it is such a simple instruction set. I have also taught using the human computer idea - we used shoe boxes as RAM - and it worked so well, I still had students months later thinking back tot eh shoe boxes whe trying to work out why their program wasn't working! I think you CAN use c# vb .Net etc in an introductory course but it is certainly tricky. I've found it works in schools where students want instant gratification - those that go on to study later are probably best served going back to assembler , though - and the teacher can enjoy the look of amazement as the kids realize just how much the computer is really doing when you write a few lines of high level language.
MVVM# - See how I did MVVM my way ___________________________________________ Man, you're a god. - walterhevedeich 26/05/2011 .\\axxx (That's an 'M')
-
I guess you'll like this: On a cultural gap[^] by Edsger W. Dijkstra
Espen Harlinn Principal Architect, Software - Goodtech Projects & Services AS Whenever methodologies become productized, objectivity is removed from the equation. -- Mike Myatt
It's almost as if he got his way, and we are non the wiser :)
-
I've seen tons of people utterly fail to grasp the introduction to programming, and to be honest, I don't really blame them. Many failed to grasp not the syntax of whatever arbitrary language the teachers decided to throw at them (often C++, Java or C#), but the core idea of programming: you're giving the computer a list of instructions that it blindly executes. So I blame the choice of language. The languages commonly used to introduce CS students to programming do not make it obvious what programming actually is, to the beginner it all looks like magic. Especially when OOP is added - without building it on top of something (the way it's usually taught is out of the blue and with flawed real life analogies), that's just pure magic. People who might (I think) otherwise have become decent programmers if they had been taught differently get stuck behind the hurdle of figuring out the core concept for themselves (while getting bogged down in abstract concepts that aren't useful at that stage yet), and give up. IMO a simple assembly language would make a much better first language. It makes the core concept explicit. It's conceptually simple. No confusing abstractions. The syntax is trivial. It really is as simple as a list of instructions. The only problem with assembly (hard-to-manage growth of complexity as projects get bigger) is irrelevant in this situation - you're only going to give assignments for simple straight line code at first, then some conditionals and loops, subroutines if you're brave, nothing unwieldy. ps: I learned z80 assembly as a first programming language so I might be biased.
harold aptroot wrote:
So I blame the choice of language.
First your implicit suggestion is that the language is to blame which entirely ignores the role of the teacher both in teaching and the choice of language itself. Second the concept of programming is difficult because it is something that no one has encountered before they actually learn it. Nothing that they have learned before is like it. Third standard programming languages do not exist to teach. They exist to solve problems. And they were designed with that in mind.
harold aptroot wrote:
People who might (I think) otherwise have become decent programmers
I doubt that. Although it is possible that more people would succeed if teachers were better. All though it would probably only be a small percentage increase.
harold aptroot wrote:
It's conceptually simple. No confusing abstractions.
Which ignores the real difficulty in that one must still get exactly the right sequence the first time for it to work at all. And you might note that there have been languages designed specifically for teaching programming. None of them have been successful in that regard.
-
Half-disagree. Within reason, language doesn't matter. It just shifts the leven of effect. An important motivation is the ability to change the world, and that's very tedious in assembly. There might be an easy way out: use assembly to control hardware - that's somethign fascinating to many programmers even after decades of doing that. There's another problem, though: The guys doing assembly. I would not want to let any of them near any budding coder pubs.
There are general problems with training programmers: The Architect teaches the mason, the biologist the butcher. There is a huge rift between Comp-Sci and Comp-Do, but they are treated as a continuum. Ideally, we make comp-sci bother more with what matters in practice, and comp-do more open to the teachings of comp-sci1. Unless we achieve that, we may need to clearly separate education for the two. There's no recipe for building software. The industry is immensely dependent on those that "get it", that have - or develop - the knack for making software. HR is unable to tell those apart from those who can't. We are unable to teach how to make software, since we rely a lot on witchcraft and snake oil ourselves.
So I would start off with: Some turtle-graphics-like[^] language very early, just to plant the seed. A mid-abstract, imperative language, to teach the grunt work, and to motivate for planning, miantenance, and further abstraction. A secondary, significantly different language, could even be logic or functional. 1) And it's not entirely comp-sci's fault. We've become very effective at ignoring knowledge that is already availabe for decades, and rather follow the newest fad. Because we are oh so special.
peterchen wrote:
There's no recipe for building software. The industry is immensely dependent on those that "get it", that have - or develop - the knack for making software.
HR is unable to tell those apart from those who can't. We are unable to teach how to make software, since we rely a lot on witchcraft and snake oil ourselves.That is overly simplistic. The number of problem domains which software can be applied is vast. And all of those domains require different solutions. And the number of domains keeps increasing at a very rapid rate.
-
harold aptroot wrote:
So I blame the choice of language.
First your implicit suggestion is that the language is to blame which entirely ignores the role of the teacher both in teaching and the choice of language itself. Second the concept of programming is difficult because it is something that no one has encountered before they actually learn it. Nothing that they have learned before is like it. Third standard programming languages do not exist to teach. They exist to solve problems. And they were designed with that in mind.
harold aptroot wrote:
People who might (I think) otherwise have become decent programmers
I doubt that. Although it is possible that more people would succeed if teachers were better. All though it would probably only be a small percentage increase.
harold aptroot wrote:
It's conceptually simple. No confusing abstractions.
Which ignores the real difficulty in that one must still get exactly the right sequence the first time for it to work at all. And you might note that there have been languages designed specifically for teaching programming. None of them have been successful in that regard.
jschell wrote:
First your implicit suggestion is that the language is to blame which entirely ignores the role of the teacher both in teaching and the choice of language itself.
I said I blame the choice of language, not the language (those languages are, as you say, not even meant for teaching in the first place, so it's not their fault they're bad for it). The role of the teacher in that choice irrelevant - it doesn't change the choice. The role of the teacher in teaching is very relevant of course, but that doesn't make a badly suited language a good choice.
jschell wrote:
Third standard programming languages do not exist to teach. They exist to solve problems. And they were designed with that in mind.
Thus making all of them a poor choice for the introduction, yes.
jschell wrote:
And you might note that there have been languages designed specifically for teaching programming. None of them have been successful in that regard.
Many have failed or are in the process of failing (some of them perhaps only through lack of notability). That doesn't mean it's inherently impossible. Some of the suggestions in this thread seem promising.
-
I've seen tons of people utterly fail to grasp the introduction to programming, and to be honest, I don't really blame them. Many failed to grasp not the syntax of whatever arbitrary language the teachers decided to throw at them (often C++, Java or C#), but the core idea of programming: you're giving the computer a list of instructions that it blindly executes. So I blame the choice of language. The languages commonly used to introduce CS students to programming do not make it obvious what programming actually is, to the beginner it all looks like magic. Especially when OOP is added - without building it on top of something (the way it's usually taught is out of the blue and with flawed real life analogies), that's just pure magic. People who might (I think) otherwise have become decent programmers if they had been taught differently get stuck behind the hurdle of figuring out the core concept for themselves (while getting bogged down in abstract concepts that aren't useful at that stage yet), and give up. IMO a simple assembly language would make a much better first language. It makes the core concept explicit. It's conceptually simple. No confusing abstractions. The syntax is trivial. It really is as simple as a list of instructions. The only problem with assembly (hard-to-manage growth of complexity as projects get bigger) is irrelevant in this situation - you're only going to give assignments for simple straight line code at first, then some conditionals and loops, subroutines if you're brave, nothing unwieldy. ps: I learned z80 assembly as a first programming language so I might be biased.
harold aptroot wrote:
to the beginner it all looks like magic
And so it should. The good teacher will then point out that it is magic that you can perform.
I wanna be a eunuchs developer! Pass me a bread knife!
-
Lucky bastadge. :sigh: OpenVMS is the greatest operating system ever, unfortunately (as with BetaMax) being best doesn't earn market share -- being "good enough" at a low price does. I haven't had an OpenVMS job for ten years now. I really only have OpenVMS systems so my skills don't get too rusty.
And I my opinion, DCL is the best command language ever. A pity that the Unix and the Microsoft guys didn't know about it (or weren't in love with it).
-
I've seen tons of people utterly fail to grasp the introduction to programming, and to be honest, I don't really blame them. Many failed to grasp not the syntax of whatever arbitrary language the teachers decided to throw at them (often C++, Java or C#), but the core idea of programming: you're giving the computer a list of instructions that it blindly executes. So I blame the choice of language. The languages commonly used to introduce CS students to programming do not make it obvious what programming actually is, to the beginner it all looks like magic. Especially when OOP is added - without building it on top of something (the way it's usually taught is out of the blue and with flawed real life analogies), that's just pure magic. People who might (I think) otherwise have become decent programmers if they had been taught differently get stuck behind the hurdle of figuring out the core concept for themselves (while getting bogged down in abstract concepts that aren't useful at that stage yet), and give up. IMO a simple assembly language would make a much better first language. It makes the core concept explicit. It's conceptually simple. No confusing abstractions. The syntax is trivial. It really is as simple as a list of instructions. The only problem with assembly (hard-to-manage growth of complexity as projects get bigger) is irrelevant in this situation - you're only going to give assignments for simple straight line code at first, then some conditionals and loops, subroutines if you're brave, nothing unwieldy. ps: I learned z80 assembly as a first programming language so I might be biased.
You are biased. :) Assembly is highly hardware dependent, but a Random Access Machine[^] would be a good idea. There is one drawback: it may be too abstract, especially if you are teaching children. My choice for first language is LOGO[^], even for adults!
-
You are biased. :) Assembly is highly hardware dependent, but a Random Access Machine[^] would be a good idea. There is one drawback: it may be too abstract, especially if you are teaching children. My choice for first language is LOGO[^], even for adults!
-
I've seen tons of people utterly fail to grasp the introduction to programming, and to be honest, I don't really blame them. Many failed to grasp not the syntax of whatever arbitrary language the teachers decided to throw at them (often C++, Java or C#), but the core idea of programming: you're giving the computer a list of instructions that it blindly executes. So I blame the choice of language. The languages commonly used to introduce CS students to programming do not make it obvious what programming actually is, to the beginner it all looks like magic. Especially when OOP is added - without building it on top of something (the way it's usually taught is out of the blue and with flawed real life analogies), that's just pure magic. People who might (I think) otherwise have become decent programmers if they had been taught differently get stuck behind the hurdle of figuring out the core concept for themselves (while getting bogged down in abstract concepts that aren't useful at that stage yet), and give up. IMO a simple assembly language would make a much better first language. It makes the core concept explicit. It's conceptually simple. No confusing abstractions. The syntax is trivial. It really is as simple as a list of instructions. The only problem with assembly (hard-to-manage growth of complexity as projects get bigger) is irrelevant in this situation - you're only going to give assignments for simple straight line code at first, then some conditionals and loops, subroutines if you're brave, nothing unwieldy. ps: I learned z80 assembly as a first programming language so I might be biased.
Good. I don't need the competition.
-
harold aptroot wrote:
So I blame the choice of language.
First your implicit suggestion is that the language is to blame which entirely ignores the role of the teacher both in teaching and the choice of language itself. Second the concept of programming is difficult because it is something that no one has encountered before they actually learn it. Nothing that they have learned before is like it. Third standard programming languages do not exist to teach. They exist to solve problems. And they were designed with that in mind.
harold aptroot wrote:
People who might (I think) otherwise have become decent programmers
I doubt that. Although it is possible that more people would succeed if teachers were better. All though it would probably only be a small percentage increase.
harold aptroot wrote:
It's conceptually simple. No confusing abstractions.
Which ignores the real difficulty in that one must still get exactly the right sequence the first time for it to work at all. And you might note that there have been languages designed specifically for teaching programming. None of them have been successful in that regard.
jschell wrote:
you might note that there have been languages designed specifically for teaching programming. None of them have been successful in that regard.
Probably because they were designed by people who taught computer science classes. They are far too enamored of making the language include their pet theoretical feature (WTF is a 'monad' anyway?) rather than concentrating on the end goal. That goal should be to teach core principles required of every programmer, whether they do embedded development or line of business apps. I also think an introductory language must be based on an existing language, possibly with syntax limitations. If you teach fundamental principles in an academic language that isn't used elsewhere, student will suffer. There will always be a 'cognitive discontinuity' when they translate those principles from the academic language to Java, C++, or whatever they're using. Knowledge of those principles must become second nature, and students won't acquire the ability to generalize them to other languages without a lot of time and experience. Longer term, I firmly believe that university computer science and engineering curricula should include a two semester sequence in real-world development, taught by a working professional. It should include undocumented and changing requirements, an unreasonable schedule, and faulty tools. The only reason I had the faintest clue about real-world programming when I graduated from college was that I worked as a programmer part-time the last three years of school.
Software Zen:
delete this; -
I've seen tons of people utterly fail to grasp the introduction to programming, and to be honest, I don't really blame them. Many failed to grasp not the syntax of whatever arbitrary language the teachers decided to throw at them (often C++, Java or C#), but the core idea of programming: you're giving the computer a list of instructions that it blindly executes. So I blame the choice of language. The languages commonly used to introduce CS students to programming do not make it obvious what programming actually is, to the beginner it all looks like magic. Especially when OOP is added - without building it on top of something (the way it's usually taught is out of the blue and with flawed real life analogies), that's just pure magic. People who might (I think) otherwise have become decent programmers if they had been taught differently get stuck behind the hurdle of figuring out the core concept for themselves (while getting bogged down in abstract concepts that aren't useful at that stage yet), and give up. IMO a simple assembly language would make a much better first language. It makes the core concept explicit. It's conceptually simple. No confusing abstractions. The syntax is trivial. It really is as simple as a list of instructions. The only problem with assembly (hard-to-manage growth of complexity as projects get bigger) is irrelevant in this situation - you're only going to give assignments for simple straight line code at first, then some conditionals and loops, subroutines if you're brave, nothing unwieldy. ps: I learned z80 assembly as a first programming language so I might be biased.
I learned Spectrum Basic, then Z80 assembler, but that's not how I'd want my son to start if that's what he wanted to learn. I disagree with assembly as a starting language. In many ways, to my mind, what's important is teaching algorithms and data structures - the language used is immaterial (within reason - I suspect Haskell may be a bad beginner's language). I'd find it easier to teach programming in C# or Java, but would want to bring it back to earth with C or C++, so that memory management was not just black magic. My 8 year old son has been learning with the help of Flowol, which is largely flowchart based. That gives the fundamentals of step-by-step processing and decision making as well as anything, but for older students I'd start with higher-level languages.
-
I learned Spectrum Basic, then Z80 assembler, but that's not how I'd want my son to start if that's what he wanted to learn. I disagree with assembly as a starting language. In many ways, to my mind, what's important is teaching algorithms and data structures - the language used is immaterial (within reason - I suspect Haskell may be a bad beginner's language). I'd find it easier to teach programming in C# or Java, but would want to bring it back to earth with C or C++, so that memory management was not just black magic. My 8 year old son has been learning with the help of Flowol, which is largely flowchart based. That gives the fundamentals of step-by-step processing and decision making as well as anything, but for older students I'd start with higher-level languages.
What I had in mind what just be for the introduction really, a month or so of assembly to get rid of common misconceptions about how computers work and what programming is, and then let them have a higher level language. Algorithms and data-structures are very important, I agree, but there's plenty of time for that after the introduction..
-
And I my opinion, DCL is the best command language ever. A pity that the Unix and the Microsoft guys didn't know about it (or weren't in love with it).
:thumbsup:
-
Brings back fond memories of teaching CS101 to freshmen in 1984. In my first lecture, I made the students parts of a human computer - each got an instruction (which they weren't supposed to share with others) and we laboriously walked through a
forloop that counted from 1 to 10. Took close to an hour to get the "program" to finish. I then asked them how long they thought it would take on a mainframe. Responses ranged from "less than a second" to "1 second". I upped the ante and asked what if the loop ran to a 100? A thousand? Ten thousand? Responses were mixed, but nobody was ready for the app to finish running in a few seconds. They were completely blown away. (Learning experience #1: computers are FAST). Next, I made the human computer subtract the index instead of counting up, causing an infinite loop. The kids saw the error right away. We then programmed the mainframe (a VAX-11/780) to do the same thing. Whoops! Infinite loop! (Learning experience #2: computers are STUPID). We didn't write code until week 2. By then, 2 interesting things occured: (1) many students dropped the course and (2) almost all of those who stayed on loved it and got nothing less than a B. It was one of the best experiences of my brief (3 year) teaching career and I was happy to receive an award for being one of the best undergrad instructors at NYIT. :) /raviMy new year resolution: 2048 x 1536 Home | Articles | My .NET bits | Freeware ravib(at)ravib(dot)com
Two posts and I already love this thread! Next time I get the opportunity to teach, I will remember that :-D
- A.
-
I've seen tons of people utterly fail to grasp the introduction to programming, and to be honest, I don't really blame them. Many failed to grasp not the syntax of whatever arbitrary language the teachers decided to throw at them (often C++, Java or C#), but the core idea of programming: you're giving the computer a list of instructions that it blindly executes. So I blame the choice of language. The languages commonly used to introduce CS students to programming do not make it obvious what programming actually is, to the beginner it all looks like magic. Especially when OOP is added - without building it on top of something (the way it's usually taught is out of the blue and with flawed real life analogies), that's just pure magic. People who might (I think) otherwise have become decent programmers if they had been taught differently get stuck behind the hurdle of figuring out the core concept for themselves (while getting bogged down in abstract concepts that aren't useful at that stage yet), and give up. IMO a simple assembly language would make a much better first language. It makes the core concept explicit. It's conceptually simple. No confusing abstractions. The syntax is trivial. It really is as simple as a list of instructions. The only problem with assembly (hard-to-manage growth of complexity as projects get bigger) is irrelevant in this situation - you're only going to give assignments for simple straight line code at first, then some conditionals and loops, subroutines if you're brave, nothing unwieldy. ps: I learned z80 assembly as a first programming language so I might be biased.
"IMO a simple assembly language would make a much better first language. It makes the core concept explicit. It's conceptually simple. No confusing abstractions. The syntax is trivial. It really is as simple as a list of instructions. The only problem with assembly (hard-to-manage growth of complexity as projects get bigger)... This is what the early versions of BASIC were for, before it got so complex.
"Microsoft -- Adding unnecessary complexity to your work since 1987!"
-
I've seen tons of people utterly fail to grasp the introduction to programming, and to be honest, I don't really blame them. Many failed to grasp not the syntax of whatever arbitrary language the teachers decided to throw at them (often C++, Java or C#), but the core idea of programming: you're giving the computer a list of instructions that it blindly executes. So I blame the choice of language. The languages commonly used to introduce CS students to programming do not make it obvious what programming actually is, to the beginner it all looks like magic. Especially when OOP is added - without building it on top of something (the way it's usually taught is out of the blue and with flawed real life analogies), that's just pure magic. People who might (I think) otherwise have become decent programmers if they had been taught differently get stuck behind the hurdle of figuring out the core concept for themselves (while getting bogged down in abstract concepts that aren't useful at that stage yet), and give up. IMO a simple assembly language would make a much better first language. It makes the core concept explicit. It's conceptually simple. No confusing abstractions. The syntax is trivial. It really is as simple as a list of instructions. The only problem with assembly (hard-to-manage growth of complexity as projects get bigger) is irrelevant in this situation - you're only going to give assignments for simple straight line code at first, then some conditionals and loops, subroutines if you're brave, nothing unwieldy. ps: I learned z80 assembly as a first programming language so I might be biased.
My first programming language was assembly also; CDC 3100 assembly language (COMPASS) in 1971. The fundamentals I learned from using assembly language served me well until this very day, from assembly language to Fortran to C to C++ to Cold Fusion to C# and VB.Net. Even if one never uses assembly language again, the knowledge one gains about how the computer actually works is invaluable. Operating system basics should also be taught as no programming language stands alone.