thecombjelly

Learn more about the features it provides: http://wiki.call-cc.org/man/4/Getting%20started

An index of the many libs it supports: http://wiki.call-cc.org/chicken-projects/egg-index-4.html

Why another lisp? http://wiki.call-cc.org/man/4/faq#why-yet-another-scheme-imp...

Getting good performance: https://news.ycombinator.com/item?id=5381472

[0] http://thintz.com?hn=t [1] https://a.keeptherecords.com/demo

Why do I love it? It can be fast, very fast. You can embed C code if it isn't fast enough.

It is very practical, there are many libs. It compiles to C which makes it pretty easy to add support for many popular libs that are written in C/C++.

A lot of schemes sacrifice speed and practicality for academic reasons, chicken scheme doesn't do this.

The community is fantastic. Everyone is reasonable and kind and helpful.

The largest one is a basic CRM for a small niche. It runs super fast and development was a breeze. I run it compiled with a number of optimizations enabled.[0]

My personal website is also built in chicken scheme and runs fast even though it is running in interpreted mode.[1]

[0] https://a.keeptherecords.com/demo, source code: https://github.com/ThomasHintz/keep-the-records

[1] http://thintz.com?hn=t

In my experience, lisp developers care a ton about performance. Most common lisp and schemes provide numerous ways to get good performance. With lisp you get power, flexibility, and performance. It gets even better when you use something like chicken scheme, which is compiled to C and allows you to embed C code.

I run multiple web servers written in chicken scheme and they perform very fast, much faster than nearly any comparable web framework, like rails.

[0] From a chicken scheme guide on programming for performance: http://wiki.call-cc.org/programming-for-performance

This sounds a lot like using bootstrap, except you have your own custom version. This would help improve the consistency of the design and make it vastly easier to iterate.

Styletiles, bootstrap and other basic web widgeting toolkits will transform the way web apps are built, saving tons of time and producing better results.

It may be an extra layer of protection related to getting the credit card number via seeing or taking a picture of the front of the card, having it on the back helps improve security from that aspect.

This will be an exciting project to watch.

=how do I do X?=

java: something similar to X is already done in Y. add abstract class and redo X and write Y. +200 LOC

lisp: something similar to X is already done in Y. realize you can generalize X and Y into a new pattern and use it for ABC too. -70 LOC

=there is a bug in function X=

java: open X.java. edit line. restart program. X seems to be working correctly.

lisp: two hours later, ah ha! I understand this code. fix X. write unit test. eval unit test. X works correctly.

[1] demo: https://a.keeptherecords.com/demo, source: https://github.com/ThomasHintz/keep-the-records

The closures that are proposed are more like a bolted on psuedo solution, basically syntactic sugar that makes the language more complex. You can only use them in SAM (Single Abstract Method) situations. If only they just added a simple lisp like lambda expression...

[0] http://cr.openjdk.java.net/~briangoetz/lambda/lambda-state-3...

edit: As noted by another comment, yaourt is the way to go.

Now that I think and write in Lisp, I find it is a much better approach to draw up one or two UI frames and then code up the UI with hard coded data. Then I just slowly build the hard coded data out and the actual app in. I don't actual engineer much at all. I just let it flow out. This leads to a much more efficient design process in terms of the time to quality ratio.

It also seems to me that every time I try to program bottom up on paper, I do a terrible job at it. It works much better when I have actual code.

The problem is that web startups tend to want to develop things quickly and be able to pivot quickly and easily. Java is not best at those things.

I know Java and worked with it for years. I do all of my startup coding in Lisp. Java forces you to do a lot of things that may make your code more reliable and easier for others to use, but it comes at the cost of being less productive, and in startups, being able to develop quickly is extremely important. That is why languages like Lisp or Ruby or Python are much more popular in the startup world.

There may be some libs that are in CL but not Scheme, but I actually have found nearly everything in Scheme that is in CL. Although some common real world problems are better addressed in CL related documentation.

...And you really only need emacs (or Vim, etc) and CL, Scheme, whatever installed. Setting up SLIME and all that isn't necessary to get started.

Sure seems like the evidence is a long ways from being able to make statements like:

Radiation from Wi-Fi networks is harmful to trees and All deciduous trees in the Western world are affected

I disagree. It is not easy, if not impossible, to go from ugly to beautiful, with A/B tests. A/B tests can make judgments on things, but they aren't going to make it much more beautiful. Making it more beautiful, and doing A/B tests, seems like the best approach.

It is more consistent. All of my code is now (in my case) Scheme. This makes it easier to change things as you don't have to go between two different languages. And it is simpler.

My favorite reason is the fact that I can use S-Exps. I no longer have to type the ending tag. I remove the possibility for spelling it wrong, or forgetting the slash. And it takes less space and is easier to get the placement correct, as you just utilize paren matching.