Using HTTPS does two things: it encrypts the data being sent between the browser and the web server so that no one can listen in, and it verifies that you're actually connecting to your web server (that someone hasn't manipulated DNS so that you think you're getting your web server but you're actually getting an evil server that wants to steal your passwords or whatever).

When you pay a registrar for a certificate, you're paying for the second purpose, so that when a user connects to your web site foo.com they know, by virtue of the registrar's certificate, that they're getting your foo.com, not someone pretending to be foo.com.

However, if all you want is for you to be able to connect to your web site securely, you don't need to pay for a certificate. You can create your own certificate (this is called a "self signed certificate", because you sign it yourself, instead of having a registrar sign it). When you connect to your web site which has a self signed certificate, your browser will put up a big warning message saying that it can't verify the certificate itself, and so doesn't know if you have connected to the right server. However, you can look at the certificate and check that it's your certificate, even though the browser doesn't know if the certificate is valid. And the data between the browser and the web site will be encrypted just the same.

On the other hand, I've heard that you can get a certificate from a cheap registrar for a little at $15/year, so if you want other people to be able to connect to your site using HTTPS without getting the browser warning, that's no big deal.

I am in the process of buying a "slice" from slicehost and setting up real website (my first time). Local8080 is getting dry as I can't show anyone the awesome things I am doing in arc!

1) As a general principle, IMO, it should be the programmer's responsibility

I myself am quite happy to have responsibility taken off my hands, if the resulting code actually works. However...

2) Adding the overhead of 'atomic

If it worked, I wouldn't mind the overhead. (I haven't measured it, so I don't know if things being made atomic by Arc adds 10% to my program's execution time or 0.01% or 0.00001%) But the way to make a program fast is to profile it and fix the parts that are slow, not to leave out useful features in order to do global, unmeasured optimizations.

However...

I don't think it does work, which is probably part of what you're saying as well. Consider

  (readfile "foo.txt")

Should I have the misfortune to say

  (obj a (readfile "foo.txt"))

For the second, well, I wouldn't be surprised if someone who worked at optimizing Arc could make it run twice or maybe even ten times as fast, while still implementing the full specification. So if a particular language feature is actually useful, and happens to cause a 10% slowdown, I mostly don't worry about it myself... I suspect greater gains would be found from a systematic optimization approach.

what's your project?

If you want your two web sites to be running with different domain names (www.mychurch.org, www.terrificrealtor.com), you have a couple options: you can run Apache (or any other HTTP server that can forward requests) in front of Arc, and be running two Arc processes, one for each site. Or you could hack Arc (or ask a hacker here to hack Arc for you) to look at the "Host" header.

Which lisp / web framework do you recommend?

For example, here's my Apache configuration:

  <VirtualHost *:80>
    ServerName desiremenu.net
    ProxyPass / http://localhost:9002/
  </VirtualHost>

Yes, if you need to keep track of things in a particular order (such as the order you added them), you should put them in a list.

Note that you can put the same data in both a list and in a table, if that is what you need for your application.

hence the storing of the table names as symbols in a table

If you want to have a mapping of table names to tables, you can store that in its own table:

  (= tables* (table))
  (= tables*!QYVSn5n1 my-data-table-1)
  (= tables*!UYg47nnb my-data-table-2)

  (let table-name 'UYg47nnb
    (let data-table (tables* table-name)
      ... (vals data-table) etc. ...

    (= my-data-table-1 (table))
    (= (my-data-table-1 'drink) 'milk)
    (= (my-data-table-1 'eat) 'eggs)

    arc> (keys my-data-table-1)
    (drink eat)
    arc> (vals my-data-table-1)
    (milk eggs)

    (= my-data-table-2 (table))
    (= (my-data-table-2 'run) 'fast)
    (= (my-data-table-2 'walk) 'slow)

    arc>(keys my-data-table-2)
    (walk run)
    arc>(vals my-data-table-2)
    (slow fast)

    (= tables* (table))
    (= (tables* '0) my-data-table-1)
    (= (tables* '1) my-data-table-2)

    (def load-ordered-tables ()
      (for i 0 (- (len tables*) 1)
        (let current-table (tables* i)
          (pr (vals current-table))
     )
      ))
	

    arc> (load-ordered-tables)
    (milk eggs)(slow fast)nil

If it turns out that you just need a list of your data tables, you can do this:

  (= tables* (list my-data-table-1 my-data-table-2))

  (def load-ordered-tables ()
    (each current-table tables*
      (pr (vals current-table))))

    arc> temp-table
    #hash((0 . (0 hUv086uP)) (1 . (1 CH3w2sdp)))
    
    arc> ((temp-table 1) 1)
    CH3w2sdp

    (= CH3w2sdp (table))
    (= (CH3w2sdp 'run) 'fast)
    (= (CH3w2sdp 'walk) 'slow)

    (def thad ()
       (eval `(vals ,((temp-table 1) 1))))

     arc>(thad)
     (slow fast)