Just on a minor note. Having taught programming classes in the past, don't use automated testing for grading, or at least not fully.
First of, there is a lot more to judge in a program than just the correctness of its output. Is the code readable ? Re-usable ? Did the student understood the core concept of the language and used them correctly ?
I saw some student fail to produce a correct program but had a well organized code. On the other hand, one of my student once created a program that was just made of switch instruction in switch instruction (up to 5 level of switches) and spread for more than 3000 lines, just because he failed to understand how function where working.
You can try to plug a linter in your testing stack, a quality gate, all kind of software to measure the code quality, but it will never be truly fair. It will make your evaluation a game where the student challenge is not understanding the concept of the class, but instead, understanding the rules of the various test you put in place. And those rules tend to be even more arbitrary with than the teacher himself.
Trying to automate grading is an engineer trying to apply its vision to education, and it my honest opinion, it is an awful idea. Providing tools to facilitate education is awesome, trying to automate education is a dystopia.
I had one professor who used private (30%) and public (70%) tests. You could iterate on the public tests up until the submission deadline. But you never saw the private tests until the professor ran them on your program after you submitted it.
I think this was a good middle ground that forced you to think beyond the rigid parameters of the public tests, and discouraged things like “switch” statements.
Quality of code was also a component, as determined by a TA.
I graded for a class that took a similar approach to this - the students had a small amount of tests available to them that allowed them to iterate over the requirements for the assignment, but we had more exhaustive tests that we ran automatically. In addition to checking test completeness, we also looked at the source code itself and graded for quality of that. The automated runner handled a lot of the hard work for us, but it definitely wasn't a situation where we saw some failed unit tests and then proceeded to fail them or anything.
The system used to pull this all off is pretty interesting, I think. It's all open source: https://github.com/redkyn
Ha, I did something very similar also with Gitlab and runners. I was always amazed at the new and creative ways students managed to break the autograders we wrote -- particularly for our BASH scripting assignments.
I was also never brave enough to have my autograders submit grades directly to Canvas after the first time I did it. I confidently had it directly submit grades the first week during the first year I implemented autograders. Half the class forgot a shebang on their shell script, and the autograder happily gave them a 0.
For bonus fun times: Gitlab's runner timeout is pretty much nonexistent if you're using the shell runner. It just won't kill them if they take too long, so I had to write our own management system for runners. Silly university IT not support containers :(
One of my favorite classes had a few simple tests provided by the professor, and the rest of the tests were provided by students. Our grade was based on our score on the overall test suite, combined with the quality of our own provided test case, our code quality as judged by a TA, and an external writeup. This was fun because it encouraged students to create brutally hard tests to cover all sorts of corner cases in a way that was openly available to everyone.
You make a good point to not use automated testing fully. I would highly recommend using some level of automated testing in every classroom.
Without automated testing, a lot of energy is spent on making sure the program runs and does what it's supposed to. Since students use all different kinds of environments (especially in beginner courses), just getting the program to run is a big challenge. Lint reports are great and I recommend adding them as part of the automated testing stack.
One huge advantage of automated testing is that students know before submitting that they understood the problem correctly, their program does what it's supposed to, and they are submitting it in the format that the instructor is expecting it in. A realtime feedback loop will always result in better submissions and grades.
Of course, once the basics are out of the way, instructors must look into the code to make an evaluation of whether the problem was solved the "right way" - whatever that means in the context of the course.
Source - I maintain a tool that automatically grades CS assignments and have collected a lot of data points over the last few years.
That would be lovely in a world where the teacher-to-student ratio was say 20:1 rather than 200:1. Most major CS programs use automated grading for lower-level programming classes; check out Berkeley's huge infrastructure and toolset for their curriculum. There just isn't enough money (or competent TA's, often) to give good individual feedback on code style in intro courses.
Perhaps it is our own fault for somehow giving administrations the impression it is possible to teach well at scales where individual attention is impossible. I don't know.
I've taught a lot of programming courses that have 20:1 or even lower ratios.
I always use automated grading to check for correctness. That way I can give more attention to other aspects of the grading rubric (a bit of style, but most of the time just understanding the thing we're supposed to be learning -- pointers, for loops, specific data structures, etc.)
For smaller programming assignments, you need to check that the right language constructs are used in the right way. E.g., you really have to go in and read to program to be certain that students are using for loops correctly. Just because the code outputs the correct answer and uses the "for" keyword, doesn't mean that the student understands how to use a for loop. I don't think it's possible to automate this check.
Similarly, it would be insane to grade a large programming assignment based on test cases alone because a) "program design" is a major part of the assignment and b) it'd be impossible to get full coverage without an insane amount of work.
I think it's a bad idea to not use automated grading, even in 20:1 classes. But of course you should also be reading the code and commenting on it.
Back when I was college (and that was a while ago now), the 2nd or 3rd year CS students would grade the 1st year CS class (which was required curriculum for all 180 students across all of our technical majors). While we did get paid to do so, it wasn't a lot. There was a strong cultural norm
that doing "grutoring" (grading and tutoring) was just what you did.
I suspect that utilizing near peer style grading would be fairly scalable.
I do understand the issue. I personally only taught in small classes of less than 30 student, and most of my own education was in small classes to.
Even with fewer student, it took my a lot of time to prepare classes, evaluations and then grade them in a way that I perceive was "fair". I don't think it would have been possible if they were twice the number of student.
> It will make your evaluation a game where the student challenge is not understanding the concept of the class, but instead, understanding the rules of the various test you put in place.
I agree with most of what you have to say, however you're arguing for replacing one 'game' with another. If the goal is not to understand the grading engine then by the same logic the goal is to understand what appeals to whom is marking it.
I do agree that you are replacing one subjectivity (the tests and tools rules) with another (the teacher view of what is a good code).
But the idea is that a teacher is not as strict as a tool and is not here to punish student, but to instead grade them fairly in order for them to see what they can improve, and provide assistance for them to improve on those point. Well at least in theory, its not that easy to do :) .
The main reason why I disliked automated grading was that, a lot of time, I could see that a student almost got the right answer, but either didn't have the time to finish, or made some small mistakes. A automated tool would have given him 0, the same grade that a student who failed to understand anything or didn't work would have had, which I see has highly unfair. He cannot have all the point, but he should have some.
Not valuing the work of students is the quickest way I found to demoralize student and ultimately have them fail the class. And this is the opposite of what a teacher should strive for.
That's exactly the point. There is more subjectivity and nuance, and the person marking it is forced to engage in a kind of dialog with the actual code and see it for itself instead of relying on some limited objective heuristic which has no capacity to understand the student and what the student is misunderstanding.
Agree, automated testing is good as far as it goes but really shouldn't be the whole story with grading.
Another fun tool is CrowdGrader (https://www.crowdgrader.org/). It's a nice way to distribute reviewing/grading throughout the class to make it more scalable. When I was teaching I really liked it, it meant I could assign more interesting creative assignments at a faster pace. It's a different type of "automation".
Back when I taught CS, I had a colleague who did this. He ran the program and compared the output char by char to what he expected. The assignments went into great detail on the expected format of the output (column-by-column). I believe this was all he did, no check of the source code. The sad thing was he was the chair of the department when I first got there. Fortunately, he retired soon afterward.
You know, this isn't a great way to teach in general, but I wouldn't mind it being "in the mix". There's a fair number of people out there who can program but don't have the discipline to understand a somewhat exacting specification.
Someone else writes of all assignments getting a public test suite, which sounds great most of the time but is even worse in making sure that students can understand what an assignment is actually asking.
I'm about to start teaching a middle school competition robotics elective. One of the two difficult grading measures is going to be tests (both closed book and open book) about what the rulebook says and means. (The other will be documentation. All the rest will be subjective and easy and squishy and "easy A").
> I saw some student fail to produce a correct program but had a well organized code.
I don't necessarily agree with this.
Programs are not designed to be readable, they are designed to solve a problem. The first goal is to get the correct program, and only after, it is important to make the code readable.
A readable code that doesn't work is not worth much.
As a former student, I think automatically graded assignment are very nice because they force you to have a programmer mindset (the smallest error / typo will make your code fail).
If you want to grade also the organization of code, fine, but I think the first one is more valuable (how to organize code properly is not learned at school anyway, it is learned by months / years of practice).
> Programs are not designed to be readable, they are designed to solve a problem.
This is 100% incorrect. If a developer submits a PR that works and if fast, but cannot be understood by the rest of the team, it can, should, and will be rejected.
80% of software's lifetime is spent in maintenance. That clever hack or ugly patch might work today, but you're going to hate yourself for it in a month.
There are exceptions, but they're by far the minority case and should be clearly marked as "deep magic".
We are talking about teaching. You guys wonder why students graduate who can't code- professors who passed them because their shit that doesn't work looked nice.
I'm heeding the way of my professor. She cut serious points from non-working code as expected but commented on our code in great extent regardless of its state.
She one to one explained to all of her students why their code didn't work. She similarly reduced grade of a working but, non-readable code and she clearly told why she did that. Also you got bonus points for informed experimenting, going the extra mile.
She always asked us hard tracing questions in exams. I complained once: "Why do I need to compile this in my mind while the compilers can do all the job?" She calmly answered: "If you can't compile that code in your mind, the compiler can't do it either.". It took me 6 years to sink that in but, when it did, I really enlightened.
With her style, you got to write working code to pass the course, regardless of all bonus points. If you can't code, you can't pass the exams either. She was great because of this.
Professors shall teach to write readable and working code, there's no exception. She was actively developing NLP systems when I last talked with her. I develop scientific applications. Both of these fields create convoluted code by default so, writing readable code is a really great ability to have.
Yes, that's good. Nobody is saying that code cleanliness is worth 0 and working code is worth 100. Working code is the most important metric but cleanliness, extensibility, etc are also important but secondary.
Your professor did exactly the same that mine did back when I was in university. Your code works? Good, you've met the minimum requirements, you'll pass. Your code has to be immaculately written and commented if you want a full perfect grade though.
Students who pass who can't code aren't the ones doing the coding (clear or unclear) in my experience. When doing homework, these students focus on higher level concepts and let the people who love coding do the actual coding.
This is based on my actual experience at university, not a random guess. It's never a case of "teachers weren't strict about working code", it's a case of "student didn't focus on coding, let others do it". Note that in proper CS (as opposed to a "coding school" or bootcamp) this is semi-acceptable, since CS is much more than just coding.
I do find it puzzling, because how can you study CS if you don't enjoy coding? But surprisingly enough, a lot of people who study CS don't actually love coding. Some actually love maths.
> Are Computer Science programs supposed to produce software engineers or people grounded in the theory?
I'm a graduate of a program called "Computer Engineering" which infuses a good deal of theory coupled with hardware and programming internals (gates, ALUs, programming language design, theory and implications, etc.)
As a person who absolutely loves coding, I immensely enjoy writing code while being able to visualize/understand how it will execute on the hardware. New CPUs blur the things continuously though.
CE mixes low and high level concepts well. I've never had a hardware class but have a copy of Tanenbaum's hardware book. It gives me hand-wavy notion of how the processor operates. But I'd never apply for a hardware programming job. Eventually I'm going to take a class in computer architecture.
While I used an "or" in my statement the reality is that most CS programs give a smattering of different CS areas including theory, SE, and hardware. SE is often one course in a 4 year program. A developer simply can't develop the skills for SE in one course.
When I was in grad school for CS I had a course with the department chair. I had been in the field for 20+ years at that point. One day she asked me for feedback on how to improve the undergrad program for students who want to go into the field. My response was a separate track that required practical year-long projects requiring SE skills. Each year the project could get progressively more involved. Students in this track would still need courses like data structures, algorithms, and programming language paradigms. But they would apply the knowledge from them to practical projects.
There's wisdom out there that an incorrect but clear and well-commented program is better than a correct but unclear one. This is quoted at least in O'Reilly's "Practical C Programing" [1], which is a pretty good book. A lot of programmers believe this, too. I think the concept has merit (without taking it to extremes, of course).
Unfortunately, correct is a function of time, and almost all correct programs become incorrect at certain points of their lives. Maintainability is a thing, and I've learned to lean pretty sharply in the direction of just shitcanning unreadable code.
As a corollary, unreadable code almost always seems to have a lot of latent bugs that simply haven't been observed yet.
I was a student, a software engineer and a teacher :) ! I have to strongly disagree with you.
The programmer mindset is not about the smallest error / typo make your code fail. This is just a restriction of the tool which you need to be able to manage if you want to use it. The electrician mindset is not about knowing which type of screwdriver to use.
As a programmer, the substance of your job is to solve a problem, which you do using various tools. Your ability to understand the problem and properly translate it within the restriction of your tool makes you a good programmer. Making no typo doesn't make you a good programmer, especially these days where you can usually really on extensive CI stack to check for this kind of small mistakes.
And, I do agree that producing a program that is correct is the first goal, but it doesn't mean that other consideration such has the quality of the code shouldn't be valued, has you said. In the same way, properly organizing code may not be the first goal, but it doesn't mean that you shouldn't reward student who clearly tried to think about their code. And, I would argue that a lot can be learned in school :) .
Overall it is all about incentive. By grading automatically, you are targeting the lowest bar possible. By grading also other aspect of the student work, you also give him intensive to work on those aspect, making him not just a machine that can pass unit test, but also a person that can reason about its own work and try to improve it.
> Programs are not designed to be readable, they are designed to solve a problem.
No. Code should be readable. When a code is fresh only you and God knows what it does and how it does. 6 month later, only God knows how your code works. You need to re-read and understand it to grasp it again.
Unless you marked all magic with big comments blocks or you wrote your code explicitly, it'll take some headache-inducing hours to re-understand it.
> The first goal is to get the correct program, and only after, it is important to make the code readable. A readable code that doesn't work is not worth much.
Again no. You can leave a non-working but readable code overnight and understand the problem tomorrow morning. You can't remember random noise after a good night's sleep (unrelated: This is why regex is hard for our brains).
> Programs are not designed to be readable, they are designed to solve a problem
I assume you've not had much experience with any legacy code where: if statements span hundreds of lines, variables have cryptic names which mean nothing to anyone but the original author (who is gone), and a distinct lack of comments.
I'm in the middle of such a project, and the lack of readability is severely inhibiting my ability to move forward. In fact, I've had to write software to parse this source code, just to follow the flow of logic.
This might be an extreme example, but it highlights how important readability is.
I believe that there is a strong argument to be made for the middle ground. Like you, I have been both a teacher and student, often at the same time, and was exposed to the trade-offs that any educational paradigm will have to make.
My current favorite approach is the one taken by Udacity in their "Nanodegree" programs. Much of the coursework is tied to autograders, which offer quick (if not very nuanced) feedback on the work performed. The culmination of each unit is a project evaluated by a human being, allowing for guidance on a more personal level.
In the absence of 1:1 tutoring, a hybrid model like this would be the base for my ideal class structure.
I have used automated when doing online courses, I will not worry about assess the correctnes, because you don't have to take that as the final result. What I did was, if it passes then I will review in depth, and check all you mention.
As in person-to-person interaction when teaching, you don't have to rely in a single way of assess if the student has understand a concept correctly, a Mediocre teachers does that
I had a very frustrating experience in an operating systems class, the first assignment was a few very basic C programs (pointer use, C strings, etc.). I used some C99 features that didn't compile without a flag in the version of GCC the grader used, so I just got a zero even though the programs were correct.
Idea: since abstractions like functions exist in order to help you prevent bugs in sufficiently complex systems being manipulated iteratively, is the problem not that testing for correctness is bad form, but that the assignment wasn't sufficiently realistic for them to need the abstractions?
I wonder if your student with nested switches was just bored with the assignment. Way back in college we had mandatory lab time which was cake for anybody with a little coding experience and I remember doing stuff like that, overflows, bit arithmetic, convoluted recursion logic and so on to see if anyone would notice. Nobody did... or so I thought.
I've been using it for all my programming units for a number of years. Whilst I don't use all of the features the main bonus for me is making the students commit code regularly and see the progress (or not!).
It also has a number of advantages, I have lost count of the number of times I have been sent screen shots of error messages (even camera photos of a screen). I now insist that all errors a reported via issues.
This means I can fix / push code for problems and track what I have done.
It also helps with plagarism as I can usually see the progress of students work with regular commits rather than one project that appears straight away via normal submission processes.
For group work there are a number of tools to do analytics on who did what etc so it make seeing how well the group has worked.
Now we are moving to online, I'm thinking of adding some of the CI / IDE features that are being introduced to help with Lab exercises, however in our area (Animation and Games) this is not ideal as a lot of what we do is visual / interactive.
> I have lost count of the number of times I have been sent screen shots of error messages (even camera photos of a screen). I now insist that all errors a reported via issues.
Hey, from someone who works on supporting developers every day, thank you from the bottom of my heart. I shake my head whenever an engineer, _an engineer_, feels like sending over a screenshot of an error that includes uuids that are 30+ characters is a reasonable way to report an issue.
I've used this https://gource.io/ for a good overview of group work then the build in analytics. Most of what I do is to download and run the code on my local machine, but I also ask for unit tests which help with the grading. All code is mainly C++ / OpenGL with python sometimes.
What about the privacy implications for your students? Do you have a way you handle that? Aren't you giving microsoft tons of your students' info ( including grades ) without the students' permission or even awareness?
No grades are on there and all the repos are private by default, yes MS get the info of the code (I've been using it since before the take over of GitHub). I think the students having public GitHub repos are good for CV / Job prospects anyway.
Maybe! I shouldn't have called user behavior a bug, and I'm sympathetic to the desire path argument, but it would hold more water if code-blocks-as-quotes didn't come with such an accessibility malus, especially given the common convention of indicating quoted content with >
I do want real blockquotes, but I can work around their lack.
let's not go back on works-on-IE-5 era. sites should work on the browsers that people use, not the other way around. i don't think it's fair that you got downvoted, though, your intention was good, you provided a solution.
That's because Firefox for iOS is really just a skin around Safari's WebKit-based engine, because Apple plays the evil gatekeeper on their app store and doesn't allow Firefox to use their own rendering engine. (Chrome on iOS is also effectively just a Safari wrapper.)
It's one of the many reasons I think iOS is a horrible choice for a privacy-conscious user.
One solution could be to create a github organisation to use with this feature, and grant the permissions for that org instead of your personal account.
This type of system seems obvious for programming courses but I wonder how intuitive it is for pure documents; the classic essay or report style assignments. At what age do kids embrace Markdown as the single source of truth for their documents?
Do technical writers within Google use Gerrit, or whatever their Perforce based review process is called, as a core part of their collaborative workflow like coders do?
I'm not entirely certain I'm understanding your concern as I don't see anything in the feature list about how they handle "pure documents". My assumption is that they expect you to use markdown for such submissions (a valid choice for programming-based learning) and you're suggesting this should be more widespread and used for teaching other subjects?
> At what age do kids embrace Markdown as the single source of truth for their documents?
I love markdown. I _want_ it to be used everywhere. But I know of adults who are barely interested in or capable of using Word/Google Docs correctly.
You want _kids_ to use _markdown_!? That is one of the more absurd things I've seen on hacker news. Up there with that guy who suggested Dropbox wasn't necessary because surely the average person can figure out how to use rsync to an external hard drive.
A sibling comment managed to take this even further by suggesting LaTeX?! You want kids, in grade school, to learn how to use LaTeX? I feel like I'm taking crazy pills! Are you all being serious? What's next, all assignments need to be submitted using JSON so teachers can program their own essay viewers?
That's obviously hyperbole, but rich text, Word or Google Docs are very clearly the best option for essay style assignments. Those options have their flaws from a technical perspective but you seriously need to look outside the hacker news echo chamber if you think this is a good idea. Many of these people are going to go into careers where if they submitted their work as a plaintext markdown document their boss is going to say "what the fuck am I supposed to do with this?"
Again, this is such a strange suggestion to me that I feel like I'm misinterpreting it. If that's the case I apologise.
I know plenty of people < 16 using markdown and latex. I don't know where adults get their information about kids but they are the ones keeping kids unaware of better tools than office 2010/2007 (which is what is used in most schools here). You can do a lot with word, yes but the point is most don't need to. Word is unnecessarily complex and the only reason most people can use it is because from 3rd grade to 10th grade, they teach it at school. No one teaches markdown or latex. This is simply a problem of familiarity.
It takes 30 min to learn markdown and maybe more to get hang of latex but I can assure you schools spend more than 30 mins to make students learn word.
And if teachers can't learn markdown or unwilling to, maybe they shouldn't be teachers given their job is to constantly relearn and teach it to their students?
Google docs or office might not remain tomorrow either - there maybe alternative but they are not open source. Isn't that problematic along with all the proprietary tools built on top of that?
lifetime of proprietary tools is short. Why not learn open standards?
Corporate leaking into schools need to stop. Government should fund open source alternatives to all the proprietary tools used in schools.
>> But I know of adults who are barely interested in or capable of using Word/Google Docs correctly.
I think markdown would work precisely because of this. Word is too hard to use and too easy to create documents that are impossible to edit by a second person.
For context. I've just watched my wife trying for 20 minutes to add one item to a bullet list, with the proper indentation and numbering of course. Mission impossible.
That problem wouldn't exist in Markdown. There is no way to accidentally do an unmodifiable list of list in a table indented by spaces.
Of course any user adoption would require a decent editor software with live preview and export to PDF.
I admittedly haven't used it in some time, but Typora felt like it would fit the bill as a solid editor with WYSIWYG live editing/preview, and export to PDF (admittedly that isn't bundled it directly, you have to install pandoc I think?)
The entire reason kids and adults should write in plaintext is in order to focus on the content of their message.
Markdown is excellent because it prevents the writer from formatting except where that has semantic meaning (headers, lists, etc).
I’m teaching my son (14) how to use the best tools: The first assignment I gave him was to write a short essay in markdown, using vscode, and commit and push the answer in a pull request on github. I can do a code review, pointing out changes or even add my own content in a commit of my own.
These are powerful tools that everyone should be learning for writing intellectual content. The diff tools and being able to navigate change history lead to improved quality. In the same way that git gives me confidence to delete bad code, when writing an essay, I can delete low quality content. While rewriting I can see the diff changes for reference.
Of course, once you are ready to “deploy”, you will have a suitable style transformation so that the final result is a perfectly formatted document (with emphasis on excellent content).
Solution: replace MLA requirements with an HTML form that accepts plain text. Teach students how to click the BibTeX link on Google Scholar, and how copy/paste works. Now they can submit their papers and citations.
Plenty of middle schoolers can handle Reddit commenting just fine. I know I wasn't the only person in high school writing essays in Neovim with Pandoc. A friend and I would do our peer reviews in English by diffing our papers.
Markdown is incredibly straightforward. I'm quite sure it's easier to pick up than a word processor; you can explain all basic formatting on half a page instead of making kids watch a series of YouTube videos on now to use [whatever word processor is hip nowadays]. Programs like Pandoc make it easy to incrementally transition to LaTeX by inlining it in Markdown documents.
I'd say that ideally, teachers should "support" a few programs, but allow students to use any program that can conform to a reasonable style. Either that, or just have students paste their essay text into a box.
> I don't see anything in the feature list about how they handle "pure documents".
True, but I’m taking the product name “Github Classroom” seriously. Maybe it should have been named “CSLab”. I think that the Scrum-like tools and processes that developers have refined over the last decade can be used in any endeavour that generates digital artifacts from text source files.
Github/Gerrit workflows seem ideal for these types of collaborative projects but I really don’t know; thus the question marks. My conclusion from your feedback is that a Google Docs-like WebUI is a requirement and my question switches to when is it appropriate to peak under the covers and see the plumbing.
> but I’m taking the product name “Github Classroom” seriously. Maybe it should have been named “CSLab”.
I also was confused about the scope they are going for with this. My initial assumption was that since it's GitHub, it's probably mostly for coding lessons. I read your comment though which implied it could be used for more generic lessons and I mistakenly assumed you had used the offering and had more info about it than me.
> Github/Gerrit workflows seem ideal for these types of collaborative projects
Are you suggesting complicated version control could be useful for e.g. some group of teens doing a 6 paragraph research paper in their social studies class? Again, that is just...so bizarre. That has an even lower chance of being easy for teachers or students to use than markdown.
> conclusion from your feedback is that a Google Docs-like WebUI is a requirement and my question switches to when is it appropriate to peak under the covers and see the plumbing.
That's totally valid. The difference between manually editing markdown and using a GUI toolbar is all that it takes for me to approve of the idea really. If there's a way to make the underlying format be markdown and still maintain the broad appeal of Docs/Word then I think that sounds great!
> Are you suggesting complicated version control could be useful for e.g. some group of teens doing a 6 paragraph research paper in their social studies class?
Yes, kinda. I am suggesting that revision history is a powerful tool. The concept of change control has long been a staple of science and engineering. So yeah, I see a group of teens working on a a three file project, Report.md, TODO.md, and Links.md very useful. The complicated part I could live without but using non-standard tools is not desirable either.
If there is a WebUI then it simply looks like a Wiki with file history.
Yeah I'm fine with that proposal as well. I think that existing wiki solutions could do what you suggest. I'm not sure if any wiki systems use git as a sort of backend and I have a feeling that a database is better suited to the task. I think you might be overestimating the need to revert to older versions to more than the level of specificity that something like Time Machine or File History provides. I also think that merges and diffing aren't necessary or useful compared to the collaborative simultaneous live editing features that Docs has.
I understand and completely agree with the core premise you're getting at here though. You want mainstream collaborative learning using proven open source tools and formats either directly or as a backend of sorts.
I thought the idea of students using git or markdown directly was silly but there is merit to using those as the backing structure for a more user friendly (and hopefully also open source!) frontend.
I really do agree that this is peak hackernews, but I'm a kid (or legal minor, at least) and I wrote both my AP exam essays in Markdown in vim; it's not really that crazy for kids to learn a plain-text prose format.
Everyone but programming instructors tend to be resistant to solutions such as this. Sadly, I only see this being used for programming courses at least for the time being, which is a shame because I can see the features such as draft iterations and commenting useful for traditional essays or reports. Even Classroom being associated with GitHub can be an intimidating barrier to entry. I hope Classroom is able to make some intuitive tutorials and example use-cases to make itself more appealing to the layperson.
Thinking back to my college liberal arts classes, I think this would’ve been great. I wish my professors would’ve required going back and revising papers—making them more of an iterative process.
Markdown is dead simple, quick and has minimal overhead. Sometimes the power of convenience trumps the power of features. It’s a trade-off. I would hate to have to use LaTeX for every small document I compose, but then I would hate to write anything longer than 3-4 pages in Markdown or that really required formatting (like a thesis). It comes down to flexibility and what the requirements are.
Yet Markdown has become the de facto standard for creating eBooks. Long and/or complex documents need to move to a multi-file build process independent of whether Markdown is used.
I'm writing some legal documents in Word alongside some documentation at the moment.
The legal documents are long documents made entirely of texts. That would work fine in Markdown. The only challenge might be the first page where the formatting is wild with logos and texts thrown around.
The required LaTeX for simple documents is correspondingly simple. You need less than 10 commands to generate a normal essay, and most are the same in everything. The power of BibTex alone makes it worth it, especially when all academic databases output BibTex entries.
It’s also in a superior league in term of install size, and more importantly, package management hell which is required for doing any basic things like handling unicode. I have memories of needing separate packages that where incompatible with each other for a single document. I finally switched to Word, which has a lot of issues too, but which at least let me include characters outside the BMP and changing their font in an easy way.
How proper is proper? You can write LaTeX for math in Markdown, getting simple prose and readable math at a loss in elegance but a big win in simplicity.
The review system at Google is just a review system. My main concern with this approach is, doing a review is tedious work. Getting the context, keeping an eye on changes, giving honest but non-offensive and actionable feedback. Clearly a good way, but fear it wouldn't scale to a classroom.
GitHub classroom is awesome and although it's been around for a while it has seen a lot of love recently, especially adding browser IDE integration and autograding.
We at Repl.it worked closely with them to make it really easy for students to start coding in seconds instead of hours. Announcement and HN discussion:
Thank you for the massive leaps you’re making with repl.it. It’s game changing how low the friction is.
How do I quickly convince my safeguarding team of the safety of repl.it and github integration?
We’re obviously concerned about pupils having contact with strangers. A much more common problem in schools is bullying. It’s also important to not allow yet another channel for harassment. Anything where pupils can privately message each other is usually quite difficult to endorse.
Thanks for the kind words. I don't think repl.it provides anymore social features than say GitHub does. How do you currently handle those concerns with regards to social coding on GitHub?
I have yet to deploy either in the classroom and haven’t really looked into where to begin. My hope is that when I start researching this I will encounter a “lock down social features to prevent bullying” checkbox, hah!
Today’s repl.it based lesson went amazingly well, yet again!
We have an upcoming teams feature that allows you to have almost a complete instance of repl.it for you, and we'll have special pricing for education, and maybe as part of it we'll add the checkbox. Thanks for the feedback. Feel free to email me amjad@repl.it with anymore feedback.
Isn't more important and effective to shut down harassers than give the harassers free roam but try to lock down the whole world to prevent harassment?
In real life, yes. With children, no. It’s harder and you really have to go out of your way to make it safe from day zero.
Much as I would love to have them run into problems which I could turn into “and the real treasure we found was the friends we made along the way” teachable moments for them, they generate far too much strife for each other without already.
Any additional tools to facilitate the social chaos of teenage life would be surplus to requirements.
We're excited about it. Cloud/browser coding being normalized is great for us.
I don't think what we're building is a direct competitor to IDEs -- you'll always need a repl in the same way you'll have a TV but still go to the movies, or you'll have a tablet but still have a desktop etc.
What a mixed feeling of (mostly) amazement and (some) disheartenment. I started looking into this space--particularly the autograder feature with full control of the execution environment, which looks look it was added to GH Classroom this March--back in 2016. I was helping teach life science graduate students how to code, and was surprised to find I couldn't find anything that fit my needs. I started working on CodeStories[1] during the few spare hours I had each week after grad school work. I made it decently far and built out a number of cool features. On the instructor side, course creation is tightly integrated with Jupyter notebooks, which is really handy. And the courses themselves have a cool level-based structure where main problems have associated side-tasks. I was able to use the site to teach several summers of courses.
I haven't necessarily kept a super close eye on developments in this space since 2016, so it wouldn't surprise me if there are other players with unique features at this point. But given that GH (arguably one of the biggest potential players here) basically just launched, there's clearly still work to be done. Personally, I had largely paused CodeStories after grad school until the events of early spring made it clear that remote learning is almost certainly going to make a resurgence. Since then, I've been putting in crazy after-work hours to figure out how marketing works (which has been intensely difficult given my lack of experience) and put a final layer of polish on a paid offering. Intermediate Python for Bioinformatics[2] starts in a couple weeks and looks like it's going to be a reasonable success. I'm excited for it and for whatever comes after it.
All that to say, I guess this is what it feels like getting scooped. I'm sure it's possible to argue that I'd already been scooped. But somehow it's different seeing it from GitHub.
Congrats to the team that built this! It looks like an amazing tool and I'm excited to see it put to use, particularly outside of the pure-CS world.
#1 Your story and the landing page are conflicting. I can't seem to understand anything about your product from the landing page
#2 It looks like its time to pivot. Find a niche which you can exploit (like bio it seems) and conquer it. Google Docs looked like it was going to dominate everything and no one had to do anything else in that space, yet Notion comes along and is now valued at $2B.
Thanks for the feedback. Do you have any particular examples that are conflicting? Would be happy to update the site to clarify any confusion.
In a sentence, the product right now is an 8-week bioinformatics course. It happens to use the CodeStories platform, which I developed, but haven't fleshed out into its own product offering yet. Does that help?
re #2: Good point; I suppose there are lots of similar examples. Zoom is a relevant one that comes to mind.
Not OP but, if CodeStories is supposed to be an education platform similar to the Github Classroom, why is the landing page selling a Python course?
Might be easier to understand by example: I'm a user that is interested in education platform, so I land on CodeStories website (because of your comment I thought that's what it is about). I see that the landing page is instead selling a Python course => I get confused and close the page thinking that I landed on wrong page.
Ah, right. That makes a lot of sense. Similarly to what I mentioned in the parent comment, CodeStories as a “platform” isn’t ready for market yet. It’s feature complete enough that I or one of my teammates can easily use it to teach a class. But the instructor side of things needs another layer of polish before an MVP would be ready to sell to teachers.
To be clear, all of our external communication for the past couple months (outside of this conversation, which is primarily about the platform) has been about InPyBio, the Python course.
Even though the separation between the platform (CodeStories) and the platform’s first course (InPyBio) is clear to me, there could obviously be clearer communication about this distinction on the site.
Happily using GitHub Classroom for programming assignments for the interview process at work. HR has the URL they send to the assignment, candidates do the work and create a PR, and then HR assigns developers as PR reviewers when the candidate is done.
I was just wondering if GitHub Classroom could be used as an interview step. I've not looked at Classroom very closely but I have a couple of questions; how do you handle the interviewees? Do they have to create their own user or do you re-use some generic ones?
If it works like I expect it to, you should be able to create different "classes" for different roles; SysAdmin, Programmer, Designer, etc. And you could create increasingly more difficult tests; build a web page, personalize it, add a cart, etc.
@maeln @pacman128 @nwhitehead, @tusharsoni, @throwawaygh, @bo1024, @elcomet, @jpm48, and everyone else intending to help us, we’d love to connect with you to improve GitHub Education. Do share your details https://forms.gle/Ni9Q8D574EWet5x27 and we shall reach out.
This seems like a great way for newcomers to learn the basics of `git` though GitHub. A great move by GitHub to try to capture this market of users who may not yet be comfortable with subversion control.
Yeah, if a student is taught Github as part of their curriculum they're more likely to stick with it.
I can't really knock it, but at the same time, this has been Microsoft's strategy for a long time, with students learning Office in school but no competitors, so they take it with them in their private and professional life.
It's a difficult one though, given that both github and office are pretty standardized / ubiquitous everywhere.
Yes, and this was a big part of the success. If someone else had built it, they might not have used it, which would have given it a much rougher time adoption wise.
Aha, I wouldn’t worry too much about it. 20 years ago CVS was the new hotness in my RCS using lab. 10 years ago it was SVN. We’re due for a seismic shift soon.
I wonder if exercism.io could have been used as well for this type of thing. Even their pitch is very similar to what's on exercism.io
> Learning through Exercism is quite different to other programming websites, with a focus on individual practice and mentor-based learning. Here's how it works. ...
The mentor feature is basically useless, there are way too many people using Exercism for mentors to be able to contact each and every one of them. Your best bet is to just do the exercises themselves and search for any errors.
I haven't used it in a while so I don't remember the pain points but that seems correct. I was mostly interested in doing the exercises and not the feedback.
What I meant with my original comment was that exercism.io had the right features for providing student feedback already, i.e. the feedback was the main point of the platform.
This depends on the language path. I've been mentoring a few of the language paths, but as an opportunity to learn/use the system, I've also been a student on a number of them. Some are overwhelmed. For instance, there was an online course on Prolog earlier this year the seemed to overwhelm the Prolog track with a glut of new students. Other tracks have problems that are harder to mentor, the code is complex, so some mentors choose to avoid those problems creating a bottleneck. Their choice is reasonable, but without more experienced mentors the problem just gets worse.
Additionally, they're working on the third version of the site. So a lot of people are focusing their attention on that, or dividing their attention between making new content and handling the current load.
I've tried to use it once to teach group of 15 students.
But I left it in favor of just public GitHub repository for each student.
It just felt too heavy for the task.
It's a step in the right direction. They face issues that plague traditional LMS systems in that LMS systems are pretty much archaic and opaque in documentation.
The CI part works well (I would expect the same from github), but things like syncing up your class roster or just inviting an ad-hoc set of students.... that's very clunky.
I'm currently teaching git to a group of about 10 content designers in the department where I work. They are enjoying it and looking forward to work more closely with developers and other designers.
This would be ideal and would definitely make my job a bit easier.
I like the tool, especially the integrations with repl. Administrative paperwork quickly becomes a massive problem for teachers and any tool that cuts down on that workload is a God-send.
I have used google classroom for courses before and I really like it. It's pretty easy to use but even so, it does create a fairly big mental over-head for most students. It's easier to forget that these days many university students have no computer experience outside of smartphones. I had one class where an assignment, a paragraph of text was submitted variously as a google document, a spreadsheet, a power point presentation and a screenshot from a phone.
I could see this being an immensely useful tool in certain contexts. I know that having something like this, as opposed to submitting a print-out of my program results during my introductory programming course (as well as just being forced to become comfortable with what a command line is for pushing commits and understanding version control) would have a big step forward at the time. Obviously, it makes business sense for GitHub as well in terms of gaining users, but I think there's a chance this is one of those times when I see a serious upside for users could also be helpful to them in the long term.
I'd hate the idea of having a record of all my mistakes as a student. I'd probably just use a separate remote for my develop branch and squash into one commit when merging to master.
Mistakes is how you learn, and (unfortunately) how you prove you're doing the work (read: the learning) yourself and aren't just copying answers or having someone else do it for you.
In a classroom setting, you don't have to pretend to be perfect. You have to learn. Perfection, polished history, etc is something you can save for your future career.
NC State uses GitHub Enterprise for the CS2, Data Structures, and Software Development courses with testing occuring on a Jenkins CI server. From my experience, student's are fine making multiple commits and appreciate the immediate feedback. Most development is done offline, though there is some attempt to game the system toward the final submission, but it's mostly done by incrementally passing teaching staff test cases.
Overall, I think this is a well received release, since it's something I know many students have appreciated in the past rather than waiting a week for teachers to grade their code.
Personally, I've found it really useful to look at student's intermediate commits. I don't judge them on it in any way, but it's extremely useful for seeing how the students are thinking about a given problem.
Seeing your mistakes might be useful in reassuring the teacher that you did the work yourself, rather than simply plagiarising the solution from somewhere else.
Git just isn't the right tool for that. If I were to use this as a student, I would push nicely sanitized and consistent history after thoroughly rebasing, amending and fixup-ing my mistakes on my local clone.
There's nothing this too can do to prevent me from doing this.
If the teacher then judges the submission by also looking at the history, I will have an unfair advantage by just having read and internalized got features.
It does. First hand experience when after couple of months of not showing any progress student shows up with completed assignment coded using constructs which where not even taught in lectures... and when asked, can not modify a thing.
I was mostly joking in my previous comment, but i know students (including myself) that have occasionally submitted assignments as a single commit passing all test cases using “novel” constructs…of course, we can readily modify it if asked to.
Does anyone have any experience using this to access recruiting assignments? Or any other such tools you could recommend for an org that is already in the Github ecosystem?
I'm wondering at which point all of those who took the blue pill and switched to github for all their code and for its networking effects come to regret this decision as github expands into and competes with their customer's business, not unlike Amazon in this respect. I'd imagine there have been a sizable number of elearning/digital classroom projects in the last 3 months due to coronavirus that might feel threatened, for example.
not a user, but this appears to be focused on programming coursework and would most likely be used to supplement an actual LMS. are there other products in this specific niche?
This looks awesome and seems to have tons of potential! I guess the main barrier here for adoption is that non-technical people might be too intimidated to learn how to utilize this properly. Maybe if the interface would be retooled to cater even to non-technical courses as well this could become a new standard for online learning.
Many course use GitHub as a part of their submission process. NC State connects a Jenkins server for their automated feedback to students. This would assist by reducing the number of platforms students need to use while learning CS.
Not when you consider how oddly ubiquitous Office was in classrooms (though it may now be seeing competition from Google?). It’s a brilliant sales strategy. Get paid now for professional training of your software, then get paid again when the kid enters the workforce and expects their company to have the software.
My thoughts exactly. While they are busy embracing Linux, they should look into adopting its mindset of having one program (web-app?) do one thing well, and only one thing. It would be a shame if the base github.com got bloated.
Accountability of submissions and recorded specific feedback for each assignment is great way to learn.
One feature I would like to see is peer reviews. Although it might cause cheating or plagiarism, it could be useful tool for peer learning. Probably can add it as post assessment step.
GitHub Education listens intently to the needs of students and teachers. We are delighted to work alongside Relp.it to help students get started quickly in the same coding environment, and allow teachers to focus on teaching instead of troubleshooting.
This just sounds like sales talk. “Listens intently” doesn’t mean anything. Even if you work in sales for GitHub/Microsoft, please just write like a human when you post to HN.
I'm teaching software development and was using freeCodeCamp.
But my students are designers, so the curriculum is often too much and I would like to strip it down. Maybe this is a way to streamline things a bit more in the future.
I so wish all of this content was public. How lovely would it be for skill development if all of us had access to these assignments and projects with auto-graded tests.
This looks great and really want to give it a try. Unfortunately, I can't add a github organization. It goes through but never shows up in my organization list.
Hi @dimxasnewfrozen,
We are working to improve this experience in Classroom. I would love to connect with you and gather your feedback. Do share your details https://forms.gle/Ni9Q8D574EWet5x27 and I shall reach out.
First of, there is a lot more to judge in a program than just the correctness of its output. Is the code readable ? Re-usable ? Did the student understood the core concept of the language and used them correctly ? I saw some student fail to produce a correct program but had a well organized code. On the other hand, one of my student once created a program that was just made of switch instruction in switch instruction (up to 5 level of switches) and spread for more than 3000 lines, just because he failed to understand how function where working.
You can try to plug a linter in your testing stack, a quality gate, all kind of software to measure the code quality, but it will never be truly fair. It will make your evaluation a game where the student challenge is not understanding the concept of the class, but instead, understanding the rules of the various test you put in place. And those rules tend to be even more arbitrary with than the teacher himself.
Trying to automate grading is an engineer trying to apply its vision to education, and it my honest opinion, it is an awful idea. Providing tools to facilitate education is awesome, trying to automate education is a dystopia.