320 karma · joined January 3, 2010
I also found the GLL paper at p. 113 [123] of http://ldta.info/2009/ldta2009proceedings.pdf
When I, as an Amateur, last looked into it, PEG[1] and extensions like OMeta[2] seemed to be the best options. I've heard good things about Parsec[3], too.
[1](http://en.wikipedia.org/wiki/Parsing_expression_grammar) [2](http://www.tinlizzie.org/ometa/) [3](http://legacy.cs.uu.nl/daan/parsec.html)
It's too late for me to edit the title, but I think "20 000" would be a good option. (The wikipedia article advocates a thin space as separator.) I would appreciate if someone could change this, since the majority here is probably American.
The e-books were available less than 5 minutes after ordering and everything went very smooth.
I actually helped beta test the game on Linux, although I didn't end up playing it much after I bought it. Nice to see you can write practical code in Scheme, too.
And seeing OMeta or similar systems makes me never want to touch e.g. Java again, where useless getters and setters alone take more LOC than the whole implementation of OMeta.
But: Today's browsers offer us a similar graphical environment we can easily modify with code and for instance knockout.js allows me to write impressively little code to achieve what I want. I'm looking forward to what people will do with the web while I try to understand what people started more than 30 years ago.
Just "[1..10]" or a simple calculation like "1 + 1" work fine.
My history teacher (in Germany) didn't mention anything about continued payments, either.
I don't know how to feel about this, but given that our own government created a huge debt after the 1974 oil crisis and again after the unification, I couldn't blame our debt on the reparation payments.
I've bought more than 25 games on GOG and I was just thinking about buying a new one (Still life) today - were there really so few people buying the games? Were the prices too low?
I hope I can still buy some of the games on my wish list - I would have already bought even more if only I had the time to actually play all these games. (I've played about half of them to date.)
I'm sorely disappointed by their sudden decision and complete removal of all access to the page. This could have been handled more professionally - why not announce closure a month in advance so people actually had the time to download everything and buy games they still would have wanted to buy?
Well, felt good to vent about it. Now to find an internet connection faster than 80kb/s to download some gigabytes of games. :-(
I didn't know much about _why until after he left. I only experienced his works later, had a look under the hood of Potion and was inspired by his passions.
In this spirit I'll take the rest of the day of and go hacking on my scanner/copier web-front-end so my family can do everything by themselves while I'm away.
My test case:
def sumTo(n):
def sumTCO(num, sum):
if num == 0: return sum
return sumTCO(num-1, sum + num)
return sumTCO(n, 0)
print(sumTo(10000000))
produces the following Haskell code (tail call optimization works!) module Main where
import Berp.Base
import qualified Prelude
main = runStmt init
init
= do _s_sumTo <- var "sumTo"
def _s_sumTo 1 none
(\ [_s_n] ->
do _s_sumTCO <- var "sumTCO"
def _s_sumTCO 2 none
(\ [_s_num, _s_sum] ->
do ifThen
(do _t_0 <- read _s_num
_t_0 == 0)
(do _t_1 <- read _s_sum
ret _t_1)
_t_2 <- read _s_sumTCO
_t_3 <- read _s_num
_t_4 <- _t_3 - 1
_t_5 <- read _s_sum
_t_6 <- read _s_num
_t_7 <- _t_5 + _t_6
tailCall _t_2 [_t_4, _t_7])
_t_8 <- read _s_sumTCO
_t_9 <- read _s_n
tailCall _t_8 [_t_9, 0])
_t_10 <- read _s_print
_t_11 <- read _s_sumTo
_t_12 <- _t_11 @@ [10000000]
_t_10 @@ [_t_12]
Which in turn produces a ~830KB binary after stripping (1.5MB before) which is linked only to gmp and the usual linux binaries, i.e. essentially static. Memory usage is also pretty low. (0.2% with 1GB RAM)Thats's the good side. The bad side: It's slow. Runtime is about 10s whereas the same code in C returns instantly and measures less than 4KB.
The ugly: It's slower than Python 2.6 which "only" takes ~6 seconds for the iterative version using range. If converted to a while loop with manual incrementing (berp doesn't support range yet), Python takes ~8 seconds while berp still takes ~10s.
I understand that it's only version 0.0x, but I'm a pretty disappointed by the speed for numerical operations - I hoped (Python compiled to) Haskell would be within an order of magniture to C. TCO on the other hand is very cool - and there's no stack limit, which is great for some algorithms easier expressed recursively.
My grand-father is in a similar situation. After years of dementia, he was diagnosed today with pneumonia after he stopped swallowing last week and reacting to people some weeks earlier. He'll die soon, but he'll die at home, where he was nursed by his loved ones until the end.
I'm glad he won't die in a hospital like my other grand-father, who died from cancer after many chemotherapies. My grandmother never gave up hope and it hit her hard when he finally died. I wished he could have died at home, even if that meant his life was some months shorter.
What happens when you open a VM inside a VM?
I even think it's the other way around: Holding the wheel is easier than changing some setting on the radio, because the latter needs "fine motor skills" whilst the first does not. It's preferable to use the hand with better "fine motor skills" - which in case of right-handed people is the right hand - for more complicated tasks.
So, the future (of dynamic language tools) is actually the past. I'll have to give it a try - I'm surely interested in seeing what ideas can be stolen for another language's editor.
Mh, out of Steve Yegge's mouth, that's interesting to hear. I guess emacs is his tool of choice now¹ and Clojure's performance is pretty good from what I've heard.
¹ (Paraphrased: "Dynamic languages need better tools", see http://steve-yegge.blogspot.com/2008/05/dynamic-languages-st...)