This is my first day obviously, but what I can see are the following interesting syntax, bare server.

   const server = Deno.listen({ port: 8080 });
   console.log(`HTTP webserver running.  Access it at:  http://localhost:8080/`);

    // Connections to the server will be yielded up as an async iterable.
    for await (const conn of server) {
     // In order to not be blocking, we need to handle each connection individually
     // without awaiting the 
    function
  serveHttp(conn);

     async function serveHttp(conn: Deno.Conn) {
      // This "upgrades" a network connection into an HTTP connection.
      const httpConn = Deno.serveHttp(conn);
      // Each request sent over the HTTP connection will be yielded as an async
      // iterator from the HTTP connection.
      for await (const requestEvent of httpConn) {
       // The native HTTP server uses the web standard `Request` and `Response`
       // objects.
    const body = `Your user-agent is:\n\n${requestEvent.request.headers.get(
      "user-agent",
    ) ?? "Unknown"}`;
    // The requestEvent's `.respondWith()` method is how we send the response
    // back to the client.
    requestEvent.respondWith(
      new Response(body, {
        status: 200,
      }),
    );
  }

Everything async await. There is an option to use a library, but it's to be deprecated,the native option is stable. Interesting import code:

    import { serve } from "https://deno.land/std@0.105.0/http/server.ts";

Sounds and looks pretty damn good.

Probably more the removal of nodejs apis in favour of browser apis. For everything. (modules/imports included).

package management, scripts are quite the shift in Deno. there are tools like velociraptor and trex which help bridge the gap, but there's still a lot to learn that's much different than node-world.

really curious how importing works and all.

So was I, so this is what I determined, on top of the official docs.[1]

On deno run of a script, it will download referenced imports and put them into a cache directory with a hash of the name. On a UNIX-like, this seems to be in ~/.cache/deno/deps (there's also a ~/.cache/deno/gen for the TS to JS stuff). Subsequent runs do not seem to download the scripts, but instead use the cached hashed versions. There's probably a way to blow out or overwrite the cache with newer download with a deno command, but I'm not sure what it is.

Compiling bundled the cached dependencies, so they aren't downloaded on run. Importing from local files is also possible, as noted in the docs I linked.

I'm happy to be corrected to supplemented on any of that info, I would rather know the actual way it works than persist in a slightly wrong assumption. :)

1: https://deno.land/manual@v1.11.5/examples/import_export

There is a compatibility layer but it is not complete.

One of Deno's objectives is not to expose V8 internals, so node packages relying on those will be harder to port