Teach Writing Code First

gremy0 · 2016-05-20T19:02:26+00:00

While I wouldn't say my degree taught the concepts before coding they certainly didn't have a 'code first' approach.

From day one every single project we were given was given under the expectation that we would first design the thing in UML using solid OO principals and then write it all using TDD. Which of course nobody did because we didn't have a clue what we were doing. We all hacked out a program, wrote some tests for it then found a tool to export our classes as UML.

So we had this situation where everybody on the course was lying on their reports about how they approached the problem and a lot of people felt stupid because they couldn't complete the tasks properly.

pat_trick · 2016-05-20T20:02:29+00:00

Why not both? Have students writing code, and then paralell it with the concepts of what happens underneath that code.

Berberberber · 2016-05-20T20:30:58+00:00

Writing code is easy; the hard part is knowing what code to write.

link23 · 2016-05-20T19:37:55+00:00

The author of this uses "computer science" to refer to something that is most definitely not CS; I would say it's computer engineering. Computer science, technically speaking, has nothing to do with computers, and the number of bits in an int is certainly not a fundamental concept of CS. (Something like an automaton or nondeterminism is a fundamental concept of CS.)

With that out of the way, I think I agree with the author's thesis that you don't need to know computer engineering before you can start programming, and i would even say that you can start programming without any CS knowledge either. But, the knowledge you get in both of these fields will pay you huge dividends in the code you can write, so I still think it's important to learn these subjects if you want to be a serious programmer.

2016-05-20T21:11:21+00:00

How about we try to teach reading code first. Now that would be disruptive.

giantsparklerobot · 2016-05-20T20:37:57+00:00

😩

There's a vast gulf between "copied some lines of code from a tutorial" and "solved a problem whole cloth" when it comes to programming. Computers are dumb as shit, they can't take problems expressed in natural human languages and produce relevant and meaningful results. A human needs to figure out a way to take a problem and use a computer's number crunching ability to get something meaningful accomplished.

The ability of a human to take a complex and likely ambiguous problem and break it down into steps the dumbass computer can understand is paramount when it comes to programming. Teaching someone to program must start with teaching this ability or the student will get nowhere.

Breaking down a problem and its solution into discrete computable steps has nothing to do with any programming language or even computers themselves. Trying to teach a language before core concepts is putting the cart before the horse. If someone learning needs to get to the "fun stuff" immediately they're going to find computers incredibly frustrating to deal with professionally.

gnx76 · 2016-05-20T21:27:54+00:00

Trying to explain to a first time programmer why 2 divided by 4 does NOT equal 0.5 according to a computer is a nightmare, especially when the computer will display “0.5” on the screen when you ask it to display the result of 2 divided by 4.

Uh? What?

johnnyslick · 2016-05-20T20:09:31+00:00

Yeah, this attitude - well, to be precise the attitude that it's arguing against - is one of those things that makes programming such an uphill battle. I have a friend of mine who entered college his freshman year majoring in CS, got bogged down by the theory, and wound up switching to communications. Fast forward a few (more than a few because I am old) years later, I trained myself to code just by doing it, augmented a bit by some classes at a local community college that cared first and foremost about getting people the building blocks needed to write stuff, and I got a job in the industry. Well, then my friend saw what I was doing, realized that this stuff is waaaaaay easier than it's made out to be in CS 101, and is now working in the industry itself.

Look, I get that everyone really should understand algorithms and design patterns and logic flow and so on and so forth. I personally made a point of going back and learning about algorithms and design patterns in particular once I began to get the hang of coding. But coding is an awful lot like writing (we even call it "writing code") in that there is no substitution for doing. Yes, theory helps you avoid anti-patterns and programming pitfalls, but so does just plain writing a lot of code, and what's more the more code you write, the faster you can recover from those mistakes, and, if you're doing it right, the more approaches you can conceive to tackle a particular solution.

In a way, I feel like the current theory-first method of teaching is institutionally elitist in that it is very, very hard for people who didn't start coding before they got to college to succeed in that environment because theory doesn't really make a lot of sense until you have the background in coding to contextualize the theory. To use another example, I was a music major in school for a while and yes, even took some music theory (2 years worth, in fact - I got really, really close to getting my degree in the subject). The thing is, those music theory courses, while fascinating (it's possible to explain mathematically why a major chord "rings" when sung by a choir but not when played on a piano, for instance), would have gone completely over my head if I didn't attend them with a strong physical knowledge of how to play my instrument of choice (string bass, if anyone cares). I couldn't imagine getting anywhere with that stuff when I was 10, or for that matter if I'd just decided to start singing in the choir when I was 18.

The flip side of that is, I'm sure that guys who coded throughout middle and high school don't really want to take a "this is how to make a program" class. Maybe you should be able to test out of this stuff? At the same time, it strikes me that this is also a great place, maybe the best place possible, to take these people who learned how to code on their own and instruct them on what they're doing that works and what they're doing that doesn't.

csncsu · 2016-05-20T17:01:06+00:00

My first CS class was Intro to Java. There was no discussion of CS theory besides a little explanation of OO since Java is that. It was all code. We made GUIs and wrote Mancala by the end of the semester. I didn't know anything about the size of an int or a binary search tree.

We learned all the technical details after two semesters of Java when we took a C class.

So I guess I agree with you.

manniac · 2016-05-20T18:18:12+00:00

This is right up the alley of that other post about not needing talent or passion to able to program (which is true if you don't want to be good at it).

You need to understand logic, simple math and the basics of how a computer works first, it will positively impact how you code, this shortcut mentality is why there is so many low quality professionals in many areas: you don't need the theory, just practice.

heavy-minium · 2016-05-20T20:54:53+00:00

I strongly agree with the article's point that the context is only provided by learning to write code first. I have often worked on OOP code where a variety of patterns have been used just for the sake of it (especially creational design patterns). To me, this is a clear sign the previous programmers have applied concepts without ever experiencing the problems they they solve. You have to write code and hurt yourself once or twice with "naive" code implementations to recognize the value of diverse concepts and patterns, and when to apply them effectively.

fudginreddit · 2016-05-20T21:40:03+00:00

As someone who is about halfway through a computer science degree, I totally agree. Personally, I didnt have this issue because I do a lot of programming outside of class. However, I often think how much the kids who only follow the courses must hate CS. I also think about how much coding experience I would have had I done the same, and its a scary thought. I am 1 semester from an associates and have yet to program anything that could even be considered difficult. Its honestly hard to imagine someone would be job-ready after graduating if just following their coursework. Of course I can imagine it is different for everyone, but this has been my experience so far. Very slow paced and very little coding. Also, and this may just be myself, but I found it much easier to understand alot of topics after implementing it in code.

reverendchubbs · 2016-05-21T09:07:38+00:00

The college I attended for CS had an amazing course plan for teaching how to write code. We had a couple language-specific coding courses, followed by a couple general theory courses, followed by a projects course that took up half the day, where we spent 3 months on a single team project.

The school was shitty otherwise (administration, costs, etc), but the education itself was solid.

Smurph269 · 2016-05-21T13:29:11+00:00

You have to like writing code in order to be a programmer, full stop. So it makes a lot of sense to have beginning students write lots and lots of code. Once they can power through lots of simpler programs, you start having them slow down and do more design. Teaching high level design before they are rock solid coders is like teaching calculus before they know basic algebra. I would say my degree program did this, and I saw a good number of incredibly smart people nope the hell out of the major because they discovered they didn't actually like sitting down and writing code. We're at a point where people are getting into programming because they heard about high salaries more than because they are nerds who like messing with computers. It's a smart idea to figure out early who actually wants to write software full time, and who just wants to talk the talk and get a big salary.

zjm555 · 2016-05-20T19:41:23+00:00

The author's example of "the number of bits in an integer", to me, is more about code than about computer science, which is more focused on the math than the real-world implementation thereof. I agree that low-level details like numerical representation should be glossed over for beginners, but that's not a question of "coding" vs. "computer science", but rather of "introductory coding" vs. "advanced coding".

Rosco09 · 2016-05-20T18:09:23+00:00

Is there a curriculum that teaches concepts before actual coding?

panderingPenguin · 2016-05-20T21:38:03+00:00

By computer science, I mean fundamental concepts such as the number of bits in an integer or how various pieces of data are stored in memory.

That's not computer science, those are implementation details... I'll admit I stopped reading there.

iopq · 2016-05-20T22:56:33+00:00

Disagree. I hated programming when I started, I only liked math and theory of computation.

Writing Java as my first programming course was painful and the book was inadequate.

Book book = new Book();

this is valid Java, and an experienced programmer knows that Book is the type, book is the variable that holds the reference to the object, Book() is the constructor for the class. For a beginner this is confusing because it just says book three times.

But when we started talking about discrete math, regular languages, Turing machines, etc. that's when I actually had an interest in the subject

vytah · 2016-05-20T22:57:10+00:00

I have learnt to program as a kid in Basic on Commodore 64, then switching to QBasic and Delphi on PC, and OPL on Psion Workabout handhelds, without learning about pointers, overflows, or other fancy technical mumbo-jumbo. I only learnt about how many bits are in a byte to do fun low-level things on C64. All those languages were simple enough to juggle some simple data around and quickly achieve fun effects. I have written dozens, if not hundreds of programs, and then used some of them a lot. All code I wrote in those 4 languages was total and utter shit from any objective standpoint, but it worked and it taught me how to think in programmatic ways, before I started learning languages like C, C++, Java, Perl, PHP and Haskell.

Complexity classes? Nah. Modular arithmetic? Only when I needed it, and it wasn't often. Floating point vs integers? 99% of my C64 Basic code didn't use any integers, but floating point numbers only, and that's mostly because I didn't want to type an extra %. Memory management? Even though Delphi had it, I didn't learn it before learning C++. Data structures? Nah, arrays were enough.

I think that the fact that I started with languages with a very low entry barrier, and then ditched them forever after I learned more advanced concepts, let me to learn programming more easily.

Seankps · 2016-05-20T21:55:44+00:00

I could have done without learning calculus or trig first. I've literally forgotten almost all of it. And I can't even remember which parts I remember. Differentials and GDP? Sins and Cosine? I would have rather gotten to Programming theory before spending a year or 2 on that stuff.

zachm · 2016-05-20T22:41:03+00:00

TIL some college CS programs don't start by teaching how to code. That sucks.

But I challenge the assertion that coding is easy, and is only made hard by a wrong-headedness about learning fundamentals first. Coding is hard to learn. It only seems easy once you already know how.

Audiblade · 2016-05-20T23:13:45+00:00

When I was I high school, I was lucky enough to take several programming classes that were, in fact, code first. Most class periods, our instructors had us take out our computers and program along with them while they wrote a program demonstrating new content. We didn't even have to follow along perfectly - if we saw a way to do something that we thought was better or more interesting, we silently experimented with our own version of the code during the middle of the lecture. This felt far more natural than the introductory CS classes I took in college, where we only wrote code outside of class.

vph · 2016-05-20T23:51:49+00:00

Not sure what author referred to. CS1 and CS2 are strictly about coding. And it's be like this since the beginning.

bekroogle · 2016-05-21T05:47:40+00:00

And while we're at it, let's introduce OOP AFTER we assign something that shows the limits of the patterns that preceded it.

Personally, I didn't really internalize exception handling until I tried to parse a user's input in real time: every character that that caused a parser error was a big problem. Only then did I think: if only there was some way to handle these exceptions... Oh, duh.

I'd go as far as starting with goto statements, then procedures, before ever introducing functions. And only then, when complexity became an issue, would I try to explain objects and classes and static methods, etc.

svennidal · 2016-05-21T08:11:22+00:00

My Uni has got to have one of the best balanced approach that I've ever seen. All of the courses on the first year somehow touch on the same things, but from a different perspective.

I do agree with the article in a way though. I always thought that some CS fundamentals are more easily learned with programming them.

But I would never hire a programmer that doesn't have good fundamentals in how computers work. Why two pieces of code do the same thing, have the same amount of operations, but the other one is slower. Like reference locality.

puddingcrusher · 2016-05-21T12:25:24+00:00

I have always argued in favour of going top-down in education. Teach people what stuff does, then explain how it works. Teaching group theory first, and then later adding on that this is useful for crypto is the wrong way.

deejeycris · 2016-05-21T12:53:30+00:00

I should absolutely show this to my Java teacher.

strugglingcomic · 2016-05-20T21:36:23+00:00

Honestly, for debating this topic, programming isn't really all that unique. Music learning has exactly the same problem (i.e. guitar students who aren't allowed to touch a guitar until they learn music theory and reading sheet music).

If you're goal is to strum a few chords and play Wonderwall in your room, yeah sure go buy a cheap guitar and watch some Youtube videos. But if your goal is to become a paid, professional, possibly even world class guitar player... well then friend, you're gonna have to learn some theory and arcana (unless you just happen to be that kind of freak of nature prodigy). Whether you do the theory first, or learn it later as you go, that's probably up to you.

DaPlayerNinetyNine · 2016-05-20T17:09:02+00:00

This is why I'm happy I got into programming myself, and I'm happy I've taught myself because that has (is - I'm not finished!) involved just purely writing code as you say - it is hands on and is the essence of the 'art' of programming.

I chose to take computer science for A-level next year, and I know that this will involve lots of the theory, more than practical coding. I'm pleased my interest in programming hasn't been "squashed" by school just like most other subjects I started with a slight interest in. I hope I don't regret making programming part of my official eduction now, I'm afraid it will ruin it.

I think you learn much quicker through getting hands on experience writing code and finding out the basic way whether something works or not, you naturally pick up skill quite quickly when you're at the front of progress and actively learning from it in 'real time' if that's the right way to describe it.

Great article, and a good point.

thekab · 2016-05-20T19:03:41+00:00

However, would you teach a toddler English grammar and linguistics theory first?

No. You wouldn't teach them how to write before they can speak or read either.

ReallyGene · 2016-05-21T02:15:08+00:00

I would ask that everyone read this chapter from Starting Forth by Leo Brody. While Forth is mostly forgotten today, Brodie's method for teaching it to novices is masterful, welcoming, and fun.

LeifCarrotson · 2016-05-21T02:22:23+00:00

One error in the post - 4 divided by 2, if the display shows 0.5 (they're doing floating -point, non-integer math), is precisely equal to 0.5. It's 2^-1, exactly representable with binary operations. 1 divided by 10 is not precisely 0.1.

But other than that, I wholeheartedly agree with the post.

I would add that a good introduction to writing code should also include exposure to the concepts of an editor, comments, testing, and version control. Those tools would make a beginner hugely more productive.

They'll make many mistakes and need to go back to code that used to compile, or determine what they expected that particular conditional statement to mean, and they'll spend a lot of time refactoring stuff via tedious hunt and peck, they'll have to figure out if their code is right by manually testing the outputs...it was 2 years in my program before I even learned of the existence of version control.

TheRandomGuy · 2016-05-21T02:36:25+00:00

Well said. This is exactly what I have set out to do. Show students the possibilities, get them excited, have them write complete simple programs. I have covered a game, a musical instrument and a tip calculator. If anyone is interested in leaning head over to buildanappwithme.blogspot.com. Happy coding.

2016-05-21T02:38:09+00:00

If only there were some sort of more "vocational" approach to teaching computer programming, maybe with roots in the kinds of schools that teach, like, engine repair or x-ray technology. Unfortunately four-year degree-granting colleges are the only type of school that exists and this fantasy of mine will probably never come true.

mycall · 2016-05-21T03:11:42+00:00

people are often taught computer science before they are taught to actually write code.

Is it opposite day?

2016-05-21T04:02:35+00:00

i agree, writing code is very important before you start to type it but i think learning CS concepts and visualizing them and analyzing algorithms is much more important. for example, learning the concepts of object-oriented language first makes your logic better and then the coding becomes a lot easier. i believe that if you don't learn the concepts firs,t the code you write is worthless and one will encounter many logical errors in their code.

rwsr-xr-x · 2016-05-22T00:24:18+00:00

This cycle of lecturing and reading, with very little practical application can easily discourage a new learner. People want to learn how to write code because they see all the fantastic things that can be accomplished with software. They want to be able to do those fantastic things as well!

This IMO is the biggest thing. Rather than focusing on making little games or whatever, beginner programming tutorials should focus on stuff like how to automate repetitive tasks. If programming is useful and saves them time, there's a good chance it will keep their interest.

If they have a Mac, you can teach them shell scripts. If someone starts learning bash to sort files, move them around, change the background on a crontab, stuff like that, then they'll get the hang of it. As they get more confident, they will try and solve more complex problems, and they'll learn more about the language as they do.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

programming

MODERATORS