Why and when would a ResponseWriter generate raw html?

I don't understand why the code is generating the view.html and post.html data correctly but displaying it all as raw text. I had been following the guide here and as I was building it, I thought that the generated html from the Execute function would be sent to the ResponserWriter which would handle displaying it, but the error I'm getting seems to indicate my understanding of Execute or the ResponseWriter is wrong.

package main
import (
"os"
"fmt"
"time"
"bufio"
"net/http"
"html/template"
)
type UserPost struct {
Name string
About string
PostTime string
}
func check(e error) {
if e != nil {
fmt.Println("Error Recieved...")
panic(e)
}
}
func lineCounter(workingFile *os.File) int {
fileScanner := bufio.NewScanner(workingFile)
lineCount := 0
for fileScanner.Scan() {
lineCount++
}
return lineCount
}
func loadPage(i int) (*UserPost, error) {
Posts,err := os.Open("dataf.txt")
check(err)
var PostArray [512]UserPost = parsePosts(Posts,i)
Name := PostArray[i].Name 
About := PostArray[i].About
PostTime := PostArray[i].PostTime
Posts.Close()
return &UserPost{Name: Name[:len(Name)-1], About: About[:len(About)-1], PostTime: PostTime[:len(PostTime)-1]}, nil
}
func viewHandler(w http.ResponseWriter, r *http.Request) {
tmp,err := os.Open("dataf.txt")
check(err)
num := (lineCounter(tmp)/3)
tmp.Close()
for i := 0; i < num; i++ {
p, _ := loadPage(i)
t, _ := template.ParseFiles("view.html")
t.Execute(w, p)
}
p := UserPost{Name: "", About: "", PostTime: ""}
t, _ := template.ParseFiles("post.html")
t.Execute(w, p)
}
func inputHandler(w http.ResponseWriter, r *http.Request) {
Name := r.FormValue("person")
About := r.FormValue("body")
PostTime := time.Now().String()
filePaste,err := os.OpenFile("dataf.txt", os.O_RDWR | os.O_CREATE | os.O_APPEND | os.SEEK_END, 0666)
check(err)
filePaste.WriteString(Name+"~\n")
filePaste.WriteString(About+"~\n")
filePaste.WriteString(PostTime+"~\n")
filePaste.Close()
fmt.Println("Data recieved: ", Name,About,PostTime)
http.Redirect(w, r, "/#bottom", http.StatusFound) //Use "/#bottom" to go to bottom of html page.
}
//os.File is the file type.
func parsePosts(fileToParse *os.File,num int) [512]UserPost {
var buffer [512]UserPost
reader := bufio.NewReader(fileToParse)	
//This For loop reads each "forum post" then saves it to the buffer, then iterates to the next.
for i := 0;i <= num; i++ {
currentPost := new(UserPost)
str, err := reader.ReadString('~')
check(err)
currentPost.Name = str
//I search for '~' because my files save the end of reading line with that, so i can keep formatting saved (\n placement).
str2, err2 := reader.ReadString('~')
check(err2)
currentPost.About = str2
str3, err3 := reader.ReadString('~')
check(err3)
currentPost.PostTime = str3
buffer[i] = *currentPost
}	
return buffer
}
func main() {
fmt.Println("Listening...")
http.HandleFunc("/", viewHandler)
http.HandleFunc("/post/", inputHandler)
http.ListenAndServe(":8080", nil)
}	

view.html

<h4>{{.Name}}</h4>
<font size="3">
<div>{{printf "%s" .About}}</div>
</font>
<br>
<font size="2" align="right">
<div align="right">{{.PostTime}}</div>
</font>

post.html

<form action="/post/" method="POST">
<div><textarea name="person" rows="1" cols="30">{{printf "%s" .Name}}</textarea></div>
<div><textarea name="body" rows="5" cols="100">{{printf "%s" .About}}</textarea></div>
<div><input type="submit" value="Submit"></div>
<a name="bottom"></a>
</form>

I've currently been reading from an empty dataf.txt file.

As hinted, it's because you haven't set the content type. Quoting from http.ResponseWriter:

// Write writes the data to the connection as part of an HTTP reply.
// If WriteHeader has not yet been called, Write calls WriteHeader(http.StatusOK)
// before writing the data.  If the Header does not contain a
// Content-Type line, Write adds a Content-Type set to the result of passing
// the initial 512 bytes of written data to DetectContentType.
Write([]byte) (int, error)

If you don't set the content type yourself, first call to ResponseWriter.Write() will call http.DetectContentType() to guess what to set. If the content you send starts with "<form>", it won't be detected as HTML, but "text/plain; charset=utf-8" will be set (which "instructs" the browser to display the content as text and not try to interpret it as HTML).

If the content would start with "<html>" for example, content type "text/html; charset=utf-8" would be set automatically and it would work without further actions.

But don't rely on automatic detection if you know what you're sending, also it's much faster to set it yourself than to run a detection algorithm on it, so simply add this line before writing/sending any data:

w.Header().Set("Content-Type", "text/html; charset=utf-8")

And also make your post.html template a complete, valid HTML document.

Also another piece of advice: in your code you religiously omit checking returned errors. Don't do that. The least you could do is print them on the console. You will save a lot of time for yourself if you don't omit errors.