thecombjelly

> Do I, as a user of the OS gain anything, or is it just easier for the kernel developers to not have to care about that?

Even if you don't gain anything directly you still gain significantly indirectly. Improvements in the speed and quality of kernel development means end users see new features quicker and bugs fixed sooner. It also makes it easier for CS researchers to try things out and make large advancements that can be easily applied to the OS.

It's true that some did. I was more referring to the history of most of the major OSes we use today and specifically when it came to the first microcomputers. Generally when they were first being used (and the OS was being expanded) security was not much of a concern.

You can have static typing with lisp if you want. There are many implementations of it actually. You can even detach the specifications of types from the code they refer to and specify the whole thing in lisp, no need to add any new syntax.

An example implementation from CHICKEN Scheme: http://wiki.call-cc.org/man/4/Types

I'm sure I'll need some help. :)

The "In Depth"[0] page addresses that a tiny bit.

In summary, 3L drops explicit support for filesystems. Instead the system just provides a mapping of labels to storage blocks. From there those blocks can be utilized in any fashion you like. A filesystem library can be written to manage its set of blocks as it pleases. A database can skip the overhead of a filesystem and directly access the blocks to improve performance.

But yes, assuming you have imported the filesystem library (which has probably already been done assuming you are at the REPL) then you can process files as regular lists of lisp data (or in whatever language you want really). Not sure that is really that special though since you can already do that.

[0] http://3lproject.org/in-depth

OSes are constantly in development. Making development faster and easier could very well lead to a more efficient system. Faster and easier development makes it easier to test out new ideas and spend more time on optimization since it took less time to make the actual feature. Sure, if hardware never changed and the feature set never changed then you could just write the whole thing in assembly and make it as efficient as possible but that isn't reality. When it comes to software requirements and limitations are always changing so making it easier to adapt to those may in the end be the more efficient solution.

> The reason your phone gets all day battery life is because the kernel was designed to run well on an i386

This is false. The reason your phone has the battery life it does is because the OS and libraries and applications have been written to allow the hardware of the phone to drop in to lower power states as much as possible. Unless the language you have written your OS in has some bizarre requirement to wake up all the hardware constantly then the language doesn't matter a ton when it comes to battery life. What matters is writing programs that wakeup the hardware as infrequently as possible.

The only major disadvantage is it takes time to develop.

The advantage is it makes development of the OS easier and application debugging easier. It is also makes future proofing the OS more robust. A program that can rewrite or inspect other programs is very powerful, in the same way lisp macros are.

One concrete advantage of this is you could write a debugger as a user application, it wouldn't have to be integrated in to the language runtime.

3L does do this. You can share as much data between the OS and user applications as you want. The OS doesn't really mediate anything so there is no overhead from copying data or messages between processes or enforcing some security mechanism. The language runtime enforces the references that are available to some code that gets run but that's it and that's all that is needed. You really don't need a separate OS program facilitating everything to serve as an OS.

Thanks. :)

Genera (and other lisp OSes of the time) proved a lot of what 3L is building on. Unfortunately at the time the hardware required to run genera was expensive. Today the atmosphere is different.

I'm the creator of 3L so feel free to ask me anything or point out how it will never work and is a terrible idea and is nothing new. :)

> is it available anywhere for us all to follow along?

A mailing list to follow development will be available soon unfortunately I haven't had time to get it up and running yet.

edit: but check back to 3lproject.org soon or the kickstarter page. If you have kickstarted it I'll also make sure to send out an update.

(creator of 3L)

No. Almost any language we use today can run on 3L and transpilers are planned for the future of 3L. The security features will still be provided via the underlying lisp though. Technically the same security mechanism could work for most languages but it is much simpler, easier, and more natural to implement in lisp.

Even languages like C can be supported safely via memory emulation (although right now that would mean it runs quite slowly but likely, although no guarantee, it will run well enough in the future as hardware becomes more powerful).

OSes designed in the 70s aren't and weren't necessarily bad. It just depends on the circumstances. When they were written they fit the times quite well. But things have changed since then.

Lisps have also changed since it was first created. Unlike many languages lisp has evolved tremendously over the years and has benefited from a tons of language research. The lisps we have today are much more than we had in the 60s.

> Nonsense! Why would you waste any resources on infrastructure when you could use them for applications. Every cycle that your garbage collector runs is a cycle that the cpu could have been sleeping and saving battery life. This concept that we don't need to care about resources anymore is absolute poppycock.

It isn't that simple. Depending on your program it can actually be slower to do manual memory management. malloc isn't free. In some cases allocating memory and performing GC is actually faster.

It's not that we don't have to care about resources at all just that we can sacrifice some of the resources to improve the situation for users and programmers. If that isn't your thing then feel free to write everything in assembly.

This isn't the same. In this case we know Amazon does it whereas with many products we don't know exactly how the item is produced. As well, AWS is not the best value whereas with commodity products the item may be the best value, from a monetary to quality standpoint. Not to mention, in most cases, technology companies can afford to pay more for a more ethical product even if AWS was the best value whereas for many people the price of a commodity is very important.

Using AWS is either laziness, the "we use Java because everyone uses Java" syndrome, or internal inertia. The only partially excusable reason is internal inertia.

Seeing as this isn't close to the first report on Amazon treating its workers horribly, why do people continue to use AWS? There are alternative companies that provide AWS like services and don't put workers in a sweatshop. So if you continue to use AWS aren't you just encouraging Amazon to do more of the same?

Thank you. (I'm the author of the library.) It came about after quite a few tries at a good API and with a lot of feedback from other CHICKEN hackers.

It probably isn't very portable right now, unfortunately. It uses a lot of CHICKEN specific things to increase speed and memory efficiency but I'm totally open to making it more portable.

It is true that it is a little more nuanced than "has no syntax". The core of the language has very little syntax relative to many of the more popular languages but it still does have some syntax. The confusion also arises because often the syntax it does have looks just the same as function invocation. "or" is syntax whereas "+" is not but they both look the same in invocation. (or fu bar) and (+ 1 2) but "or" is short circuiting and "+" is not. "or" is syntax but it doesn't look like the syntax a lot of people are used to.

In fact, if you use scheme extensively you will probably use more syntax than most languages. Scheme and other lisps are very good at allowing you to create new syntax which is very helpful in creating DSLs which you will run across a lot in scheme libraries and the SRFIs.

Here is an article discussing the utilization of this technique specifically for CHICKEN scheme.

http://www.more-magic.net/posts/internals-gc.html

The problem I have is I don't look through my fridge, freezer, and pantry every day to see what things are going to go bad soon. I often forget about something I have, especially if it ends up behind or under something else. I don't end up rediscovering it again until it has gone bad.

The app also makes it easy to quickly get a handle on the ingredients going bad soon so that you can think of something to make with them. I've also found myself using it in the grocery store when I'm trying to remember if something I have has gone bad or not yet.

Just searching the list to see if I even have something is very useful too. I used to end up buying something twice since I forgot I had already bought it a while ago.

I came here to say the same thing about Michigan where I lived before moving to California. When I moved to California I was under the impression that it was a very environmentally focused state and that they surely would have as good of a system as Michigan but I was quite surprised when it turned out not to be true.

> almost every major grocery store has machines that process can returns - completely self service, at almost every grocery store. The grocery stores use it to get customers in the store

I was under the impression that any store that sold a returnable was actually required to accept them. Stores that didn't have automated machines counted them manually and gave you a cash refund.

When I first moved from California from Michigan I dutifully saved my cans and eventually asked someone how to turn them in since I hadn't seen any bottle returns in the store. When I found how you actually redeemed the deposit I was quite upset. Not only is it hard to find a recycling center but they are often not even open. It is a good example of the implementation of the same thing having vastly different outcomes in unexpected ways.

As a side note, Michigan is quite interesting in general when it comes to taking care of the environment. In many respects the people care a great deal about keeping the endless lakes and streams clean and keeping nature healthy. Unfortunately there are still a lot of remote areas where it is very difficult to do the best things. I once lived in an area that had no garbage service and the nearest garbage and recycling center was over an hour away. Most people in that situation end up burning their garbage. And, of course, air pollution in general is nearly ignored due to the love affair with large, old automobiles.

Also checkout M5 hosting[1][2]. They have excellent customer support and I've had no issues since I started using them a few months ago. I currently have a dedicated freebsd server, for $209/month:

Xeon X3450 Quad Core, 32GB ECC RAM, 2x 500GB HD, and 2TB/month bandwidth plus a whole bunch of extra IPs allowing me to run numerous jails for hosting all sorts of sites and dev-environments. Very good machine for the price. You can still pick one up [3].

[1] http://www.m5hosting.com [2] They are also working on a an amazon AWS competitor service. [3] http://www.m5hosting.com/buynow.php

> Is there something like a web framework for it?

Yup. It is called 'awful'. :-) [0]

It is still more bare bones compared to something like rails or django but we are continually improving it. It is very straightforward and easy to get started with, and it is already quite powerful. You can do most things in it as easy or sometimes even easier than in more popular frameworks. You do have less web-framework-specific libraries to work with though.

edit: awful can also be done with SXML which prevents XSS attacks be default.

[0] http://wiki.call-cc.org/eggref/4/awful

As far as I know chicken meets all of those requirements quite well. Chicken starts up extremely fast even for very large applications as long as you compile it.

The library ecosystem is obviously not as well developed as a major framework like rails or django but it is growing fast and covers most things you would need. A large benefit of it compiling to C and having great FFI support is that most libs don't have to be reimplemented in scheme but can just have a binding to an already mature lib.

edit: And if it doesn't have what you need the community is great at helping you get on the right track adding a new lib and gladly accepts well done patches.

chicken scheme runs on both android and iOS devices. I also know of at least one company building apps with chicken scheme.

[0] https://github.com/chicken-mobile

[1] http://www.bevuta.com/

I learned lisp a few years ago originally with Paul Graham's ansi common lisp and built a few products in various common lisp systems but after a while I really fell in love with scheme. I tried out numerous scheme ecosystems and fell in love with chicken very quickly.

Since I found chicken scheme I have used it do everything I can. I have built numerous web applications using it and it always makes my happy inside; something I can't say for other ecosystems. It also works great for scripts and interfacing to system libraries.

And of course the community is amazing. Even when I was new to lisp and chicken my questions and patches were always taken seriously and responses are always kind and helpful.

As felix mentions chicken scheme is really fast. Even on websites with moderate load and very little performance profiling or caching my dynamic pages are very consistently generated in less than <20ms. If you go a bit further and give the compiler hints it gets even faster. And if it isn't fast enough yet you can embed C code straight in your lisp source files.

It is tough to beat a language and ecosystem that nearly never gets in the way, is easy for rapid prototyping, and gets great performance when you need it.

As mentioned, Henry Bakers "Cheney on the M.T.A"[1] is a great read. I have used it to implement a scheme system as well.

In summary: use chicken scheme if you want a nearly mature, production ready, rapid prototyping, statically or dynamically typed, fast, easy to use, and powerful language and ecosystem.

edit: Another really cool feature of chicken scheme is the ability to serialize continuations. It can be used to make an extremely powerful stateful web app that operates like arc and hacker news.[2] Since you can serialize the continuations you can write the state to a file and you won't lose the state when you restart the app or the server crashes.

[1] http://home.pipeline.com/~hbaker1/CheneyMTA.html

[2] http://wiki.call-cc.org/eggref/4/suspension and http://www.paulgraham.com/arcchallenge.html

Over what time period? We have an average of less than 1 exception per month.

I have also worked on a larger web app that would get thousands of exceptions per day.

I think near 0 is very possible as long as you aggressively attack all exceptions as they show up. Once you start letting some go they tend to pile up exponentially. I keep my phone on me and every time, day or night, that an exception occurs I get notified; it keeps me very motivated to fix problems quickly.

C# is quite impressive, especially in comparison to Java. If it had been released earlier, wasn't owned solely by Microsoft, and supported all major platforms equally, it could have been huge, even larger than Java. If C# had reversed roles with Java a significant portion of the world would have been more productive.

The inclusion of lambdas is great, but not supporting full closures severely hampers their usefulness. Instead of using lambdas to use patterns like CPS (continuation passing style) or alternative object interfaces, lambdas just save you from typing extra characters.

It is always fun to watch other languages continue to implement features that bring them closer to lisp. I wonder how much longer it will be until every language is just a lisp dialect.

They are moving in the right direction but very slowly. It is impressive though that they have been able to still innovate without breaking backwards compatibility.