Can we detect unformatted code and give specific help?

Question

This is related to this feature request around "training videos" but is more specific.

It seems to me that it wouldn't be too hard to make a pretty good guess about when a question contains code that isn't formatted. Some heuristics would be biased towards particular languages, but even so, I think the team could make some good guesses. Heuristics might include:

• Consecutive lines which contain amounts of whitespace differing by 4 spaces in several places
• Common programming language keywords
• Lots of symbols compared with normal text
• Potentially language-specific detection: semi-colons at the end of lines, braces on lines on their own or at the end of lines
• Single-letter words other than "a" and "I"
• Long words with underscores or capitalsWithinTheWord

In an ideal world, it would be great to guess at the precise chunk of text which contained the code, and present the user with a choice:

It looks like you were trying to post code, but didn't know about the formatting. Did you mean it to look like this (original) or this (formatted)?

User then chooses the appropriate option, and is shown what they should have done in the input box as well.

Answer 1

Per

Simple method for reliably detecting code in text?

We just deployed a method that we think is quite reliable for blocking 98% of posts submitted with code that has improper code formatting (or no code formatting at all).

For example, when I go into Chrome incognito and attempt to ask this question body on Stack Overflow right now:

I needed to add up all the rows for a result. Using the select_sum as follows

Here is the model

function Dues_Paid_Tot($date)
    {
        $query = $this->db->select_sum('Dues_Paid', 'Dues_Paid_Tot');
        $query = $this->db->get('Membership');
        return $query->result();
    }

Here is the controller

function Fiscal2()
    {
    $date = $this->input->post('Select_Date');
        if($query = $this->report_model->fiscal_list($date))
        {
            $data['records'] = $query;
        }
    $data['date'] = $this->input->post('Select_Date');
    $data['Dues_Paid_Tot'] = $this->report_model->Dues_Paid_Tot($date);
    $data['main_content'] = 'report_fiscal_view';
    $this->load->view('includes/template', $data);
}

I get back:

Oops! Your question couldn't be submitted because:

Your post appears to contain code that is not properly formatted as code. Please indent all code by 4 spaces using the code toolbar button or the CTRL+K keyboard shortcut. For more editing help, click the [?] toolbar icon.

This check is limited to users with <= 50 reputation and is performed on questions / answers / edits and suggested edits.

If you see or hear of any cases where this is triggered inappropriately -- or not triggered, and it should have been -- let us know.

Answer 2

Good idea. Another dead giveaway is the use of the <code> tag. People sometimes attempt to format code using rules they already know from somewhere else, with results like:

#include 
#include 

...

Answer 3

I don't think that the rules around detecting malformatted code needs to be that complicated. From what I've seen newline characters in markdown that don't correspond to a corresponding new line character in the displayed post is unintentional more often than it's not - a high number of these in a post (maybe more than 1 occurrence per 50-100 characters) is probably a strong indication that the user needs some help.

This would also catch the times where users get things wrong outside of code blocks (which is also pretty frequently).

All they would need is some subtle prompting:

• Select code regions and press the code button to format code correctly
• Use two newlines to separate paragraphs
• etc...

I also can't see any real benefit in showing this more than once per user - if they didn't read it the first time its just going to be annoying the second time and the same information is now easily accessible with the new Inline Comment and Post Markdown Help if they ever want to find it again.