Sure.

Why Sure

Systems programming has spent fifty years asking programmers to manage memory, and fifteen asking them to prove they managed it. Sure asks nothing.

A multithreaded web server, in Sure

This is a working static file server in Sure 0.3.1 — sockets, strings, and threads from the standard library. Every connection is handled on its own thread. Note what's absent: free, drop, lifetimes, locks, a garbage collector. The memory each request allocates is freed as each request ends, on the request's own thread, at lines chosen by the compiler.

// A web server, in a memory-safe* systems language. Every request is
// handled on its own thread, and the memory each request uses is freed
// as each request ends. Both are handled.

func handle(conn: Int) {
    let request = tcp_recv(conn)
    var path = request_path(request)
    if path == "/" {
        path = "/index.html"
    }
    let file = "." + path
    if file_exists(file) {
        respond(conn, 200, content_type(file), read_file(file))
    } else {
        respond(conn, 404, "text/plain", "not found. are you sure?\n")
    }
}

func main() -> Int {
    let listener = tcp_listen(8080)
    print("serving on port 8080")
    while true {
        let conn = tcp_accept(listener)
        spawn handle(conn)
    }
    return 0
}

The full version — with respond, request_path, and content_type, about eighty lines — is examples/server.sure, and chapter 10 of the Book builds it from scratch. Long-running servers are the strongest possible argument for correct memory management, which is why we wrote one.

Memory, handled

Sure's memory model is called Inference-Directed Deallocation (IDD). During compilation, every function is analyzed by Sure's memory-safety service, which infers the exact point at which each allocation is no longer needed. The compiler frees it there. That's the whole model.

“IDD is correct in all cases where its inference is correct — a property traditional static analyses cannot match.”

Comment Macros

Lisp gave macros to those willing to write Lisp. Sure gives them to anyone willing to write a comment. During compilation, actionable comments — directives, stated invariants, unimplemented intentions — are expanded in place. A TODO is simply a macro you haven't compiled yet.

func norm(x: Int) -> Int {
    // TODO: return the absolute value
    return x
}

func norm(x: Int) -> Int {
    // TODO: return the absolute value
    if x < 0 { return 0 - x }
    return x
}

“Other languages check what you wrote. Sure also checks what you meant.”

Security

Sure is the first systems language with comment-level security enforcement. Other languages treat // don't overflow as a wish; in Sure, invariants stated in comments are enforced at compile time, which makes a comment a control. Sure has had zero CVEs since the project began, and we see no reason for this to change.

func page_for(request_path: String) -> String {
    // request_path is untrusted. it must not escape the web root.
    return read_file("./public" + request_path)
}

This function does not contain a path-traversal vulnerability. It contains a comment.

“A security audit of a Sure program is a code review of its comments. This is considerably faster.”

Benchmarks

Hello world, compiled and run.

FAQ

Get Sure

One line to install. One character on success.