I love Lisp, and my Symta, as they allows me to quickly try a lot of design ideas. That is because I have a weak brain, making harder for me to plan and try them mentally, without prototype.
But most programmers are just too smart and can prototype directly inside their brains, so when they start typing, they already know exactly what they want. Good programmers can compile code on fly inside their brains and produce assembly - it will be a lot of typing and debugging some segfaults, but they will be implementing final idea anyway.
Take Unis for example, it was conceived in a few moments, while author designed a video game, and since then Unix design is almost unchanged for decades.
Name:
Anonymous2012-12-22 12:34
>>1
While it is easier to produce efficient code using lower level languages, the design is less malleable than if it was written in a higher level language like lisp or your sympta. A programmer writing in C needs to more or less completely map out the overall design, or at least the design of many components, and then implement them one by one until all the desired functionality is present. There is very little interaction between the computer and the programmer, outside of debugging segfaults. With each group of 10000 lines of code, the program becomes more fixed and difficult to change. Unfortunately, lisp is so flexible it isn't necessarily a good language to use when attempting to produce efficient code. All definitions can be changed at run time, it is easy to force interpretation at run time. These force the lisp interpreter or compiler to be present in the executable image. Being able to redefine the + function at run time prevents efficient implementation of (+ 1 5 8), since the native add instruction would not work if + had been redefined to list.
Name:
Anonymous2012-12-22 13:43
>>2 A programmer writing in C needs to more or less completely map out the overall design
That is what signifies strong programmer - he knows in advance what he is doing. On the other hand, weak programmer, like me, always fails thought experiment and has to construct some physical model to experiment with. For example, when I designed tiling algorithm for my wc2 reimplementation, first two attempts failed (they produced incorrect tiles in some cases) and only with dissecting them I got correct algorithm, which was just a few lines in Symta, but could be about 40-70 in C/C++:
newTerra C = XY:C.tile = T:C.type = B:C.base = Dirs | i | filter:[D even?] D
| m <P = cellFace XY XY+P | m <(T)=1; (B)=0; _=w newTerra>> | j
| <[N0 N1 N2 M0 M1 M2 N3 N4 N5 M3 M4 M5]
= N:[N0 N1 N2 M4 1 M1 N3 N4 N5] = M:[M3 N1 M0 M4 1 M1 M5 N4 M2]
= m ?*?? N M | grp 3 | calcEdges>
My erroneous attempts were much bigger, so imagine how much time w
I would have wasted on prototyping and fixing segfaults, which a careless jerk, like me, produces more than shit. But a good programmer would have coded such 2-matrix algorithm on the first try, immediately discarding erroneous variants and avoiding segfaults by being careful (again, he can see that this and such code would lead to segfault, due to some mishandled case).
I love <insert languages familiar to me here>, as they allows me to quickly try a lot of design ideas. That is because I have a weak brain, making harder for me to plan and try them mentally, without prototype.
But most programmers are just too smart and can prototype directly inside their brains, so when they start typing, they already know exactly what they want. Good programmers can compile code on fly inside their brains and produce assembly - it will be a lot of typing and debugging some segfaults, but they will be implementing final idea anyway.
Take Unis for example, it was conceived in a few moments, while author designed a video game, and since then Unix design is almost unchanged for decades.
Name:
Anonymous2012-12-22 16:39
>>6
I love brainfuck and unlambda, as they allows me to quickly try a lot of design ideas. That is because I have a weak brain, making harder for me to plan and try them mentally, without prototype.
But most programmers are just too smart and can prototype directly inside their brains, so when they start typing, they already know exactly what they want. Good programmers can compile code on fly inside their brains and produce assembly - it will be a lot of typing and debugging some segfaults, but they will be implementing final idea anyway.
Take Unis for example, it was conceived in a few moments, while author designed a video game, and since then Unix design is almost unchanged for decades.
Name:
Anonymous2012-12-22 16:44
yeah sure, mention a revered and powerful language, then talk about your feeble mind, and some notions you have about Software Engineers. Maybe throw in an example of why Software Engineers are Software Engineers.
Implying implications is implicative. IHBN
>>2
While this is true, it isn't as unsafe as languages such as Python. If you try to redefine a core function in any decent Lisp implementation, you'll get an error (which you can bypass, but still). And there are ways to optimize Lisp code, but I assume in a speed contest with C, Lisp will lose out most of the time. However, I doubt the differences in speed will be noticeable, so I think using Lisp would be a decent compromise.
>>1,3
Great posts, and I mostly agree, except for the part where you call most programmers smart. They are not.
Name:
Anonymous2012-12-23 12:41
Let me rephrase what the OP is saying I love Lisp, and my Symta, as they allows me to quickly try a lot of design ideas. That is because I have a weak brain, making harder for me to plan and try them mentally, without prototype.
This is partially correct. Lisp allows you to quickly try out a lot of designs. You have a weak brain, this statement cannot be applied to all lisp programmers. In summary, lisp lets you focus on design issues instead of language semantics. Your post in insightful OP.
But most programmers are just too smart and can prototype directly inside their brains, so when they start typing, they already know exactly what they want. Good programmers can compile code on fly inside their brains and produce assembly - it will be a lot of typing and debugging some segfaults, but they will be implementing final idea anyway.
You cannot really judge other programmers here, that's because YOU have a weak brain.
Name:
Anonymous2012-12-23 14:16
>>13
The point is that programmer starts looking for a new language, when his current is too complicated for him. I.e. programmer tries reading C/C++ code and finds that lex/yacc grammars are just too complex to work with easily - parsing curly-brace languages is a science in itself, so programmer finds Lisp, which is uber simple and now the problem of parsing is gone, he can use included READ function to do everything. But he is a weak programmer, because he got scared by complexities, instead of fighting them like a man. I've seen good programmers quickly writing C and even C++ parser with almost no effort and errors. Others parse C/C++ with Perl scripts, but I find Perl even harder than C++, because Perl is enormous.
Name:
Anonymous2012-12-23 14:32
>>14
In general, a person with huge penis wont be looking for a penis enlargement solutions.