ScholRLEA's fetish for licensing and LISP thread
-
I may be outing myself as a stupid when I say this, but I believe the fundamental problem with Communism is the same problem with Lisp: it is a mechanical attempt at a solution for what is a human problem.
The problem with bad code is not really the language. As has been pointed out repeatedly, you can write bad code in any language. I don't think the messiah of programming languages is ever going to solve that. Increasingly refined technique and better understanding of the problem domain is the real solution, but that's going to take at least a generation or two - and we'll always have the problem that any schmuck who walks in off the street can start writing code. TOPIC RE-RAILED!
Emphasis mine.
I totally agree that the language doesn't limit how bad of code one can write.
However, the language can limit how good of code one can write. The ability to apply technique can depend on what tools one is using.
-
So, basically, you don't know what you're talking about and don't want to because it would invalidate your feelings.
A brief history of everything @blakeyrat ever posted.
-
@ScholRLEA said:
I do believe its name begins with an 'l'. Or do you think it sprang out of thin air?
Is it... I don't care? That starts with an 'I'.
And yet it hasn't changed the world.
I believe his point was that it did.
-
However, the language can limit how good of code one can write. The ability to apply technique can depend on what tools one is using.
Exactly. And whoever doesn't agree can write his next project in COBOL.
-
blakeyrat said:
ScholRLEA said:
I do believe its name begins with an 'l'. Or do you think it sprang out of thin air?Is it... I don't care? That starts with an 'I'.blakeyrat said:
And yet it hasn't changed the world.@blakeyrat said:
NO! NO! IT DIDN'T! IT DIDN'T! IT DIDN'T! IT DIDN'T!
Just forget it.
-
Tell me, now, what feature was recently added to both Java and your beloved C#? I do believe its name begins with an 'l'. Or do you think it sprang out of thin air?
You mean like all the new things in Java8, or the async stuff in c# 5? Or pretty much any of the new vNext stuff in 4.5.x ctp?
Or were you going for something else?
(If you were going for interfaces, your definition of recent is kind of skewed)
-
(If you were going for interfaces, your definition of recent is kind of skewed)
Well keep in mind, this guy didn't know about TFS. This might be time-pod territory.
-
I think that's a lowercase "l" and not a capital "I" or a "|".
-
-
Yeah, it should be LisP.
-
Sorry, that was a lower-case 'L', not an upper-case 'I'. The feature I had in mind was lambda expressions, which were introduced into C# 4.0 and Java 8.0. OK, so C# 4.0 wasn't that recent (I thought it came later), but Java 8 is only still getting rolled out.
-
Says the guy who still writes Lisp in all caps.
Says the guy whose username is antiquarian!!!!!!!!!!!~!!!!!!!!!@11
-
Then my answer becomes:
Li don't care.
-
Lambda expressions existed in 3.5... which was circa 2008, so.. where have you been?
http://msdn.microsoft.com/en-us/library/bb397687(v=vs.90).aspx (check previous versions if it doesn't go straight to 2008.)
-
I stand corrected, then.
-
Then my answer becomes:
Li don't care.
What does lithuim have to do with this? Or is this your subtle way of saying you're off your meds again?Filed Under: even on my meds, I'm pretty crazy, as you may have already noticed
-
I'm pretty crazy, as you may have already noticed
We definitely noticed.
Edit: You don't have to be crazy to post here, but it sure helps.
-
So who would write software? Super-intelligent energy beings from Jupiter?
The New Soviet Man!
-
I vote @blakeyrat should build software.
-
I second the motion for @blakeyrat.
-
LISP had its chance to change the world. It's had FAR MORE of a chance than, say, BeOS ever did. And yet it hasn't changed the world.
It has changed the world. It's the language which other languages raid for cool stuff (before putting on some non-sucky syntax, which is the one thing that the Lisp crowd never understood at all; a language's syntax is its User Interface). But unless you're doing programming language design, you won't see the ways in which Lisp has changed things. They're indirect.
Nobody sane writes software in Lisp. I tried it once, but I got better very quickly. (An IDE shouldn't take 30–40 minutes to start, though this was in 1995.) To know how deeply twisted Lisp is, think of it like this: Richard Stallman likes Lisp.
-
People have tried to make real things in Lisp. Few have succeeded. Most have regretted and switched to something saner.
-
It has changed the world. It's the language which other languages raid for cool stuff (before putting on some non-sucky syntax, which is the one thing that the Lisp crowd never understood at all; a language's syntax is its User Interface).
That's where Lisp weirdos like me get really odd: they prefer the lack of syntactic sugar in Lisp. There's something to be said for a language where there is a single basic syntax for nearly everything, and as few exceptions as possible. You hardly need to learn anything except function calls, a handful of literal types, and a few special forms. Most people can learn the core language (especially in Scheme) in about an hour, if they bothered to. It's liberating after a fashion, actually, especially when you get to macros.
The thing, of course, is that you have little to guide you as far as syntactic structure. Most people try to read Lisp and see nothing but parentheses everywhere, and are so put off by the lack of special constructs for conditionals and iteratives that they just throw up their hands in disgust. It is exactly the free-form nature which Lispers so adore that keeps most people away, unfortunately.
-
What, if anything, would be my alternative?
The real question is: why do you wanna do what you wanna do?
You said that you don't want to go into business with this project - so I'm assuming that making a mint off it is not your goal. So what is?
-
If I'm going to defend Lisp, I might as well pull out the big guns, the one thing Lisp has most language can't do on the same level: macros.
OK, so this is a bit of a controversial subject, in part because most people only know macros from C and assembler, and think, 'eh, what's the big deal?' or even 'what? Why would you want something so dangerous?' The thing is, Lisp macros are of a completely different order from the kind you have in C, so much so that Lispers can get deeply offended by the comparison and the conversation stops right there. It's also controversial for a few other reasons, though. Lisp macros really are very different, but they also can be really, mind-bendingly complicated to understand. Even a lot of starting Lispers avoid the topic. Finally, there's a huge debate over 'classic macros' a la Comon Lisp, which are hairy to get at first and have some issues that can be trouble if you aren't carefully, and 'hygenic macros' like in Scheme, which are simpler to learn the basics of and avoid certain of the pitfalls of classic macros, but are harder to work with for more complex macrology.
The other reason most non-Lispers get put off by macros is because they generally get explained really badly, with poorly considered examples. The example you hear most often (and one I've used myself in the past) is, 'you can write a for loop macro using just the basic primitives!' In fact, here's a slightly more complicate than usual example of just that:
(define-syntax for (syntax-rules (break) ((for (sym x y) forms ...) (call/cc (lambda (endloop) (let ((break (lambda ret (cond ((null? ret) (endloop 'done)) (else (endloop (car ret))))))) (let loop ((sym x)) (if (= sym (+ y 1)) (break) ; Body here (begin forms ...)) (loop (+ sym 1)))))))))followed usually with this trivial example:
(for (x 1 10) (display x) (if (= x 5) (break)))The usual reply to this is: 'so why doesn't Lisp have a for loop in the first place? what a waste of time!' often with the added 'Besides, it still looks like Lisp, are you sure it's a for loop?'
So it's a shitty example, and most of the starting Lispers who are inclined to try to defend the language but don't really know macros well themselves yet get pissed off because the audience can't see what a brilliant, world-changing thing this is, and give up trying to explain it. Which sucks for everyone.
What's really missing in the usual conversation is, just what is a Lisp macro? Simple: it's a program that writes new programs on the fly. It goes beyond what you can do with an ordinary function because it is actually generating new code, before it gets compiled, and unlike C macros, you have the full weight of the Lisp dialect in question behind you in writing the generated code. Most Lisps use macros for everything, including things most people usually think of as part of the language. It's been demonstrated that you can write a full (and reasonably efficient) version of Scheme with nothing more than macros spitting out lambdas and the basic list and literal syntax; actually, even the syntax for the literal forms can be done in macros, though they usually aren't for efficiency's sake. This is a mind-blowing thing to a Lisper, and absolutely pointless to most non-Lispers because that's what the compiler is for.
'Yeah, but the Lisp compiler/interpreter is much smaller than the one for C++!', says the Lisper, while the audience yawns. Because you can apply this to any language extensions you want. You're dialect doesn't have OOP support? That's a few macros away. You want a special syntax for, say, multi-path random choice? Voila, a macro. You can hack the language itself. And that's why Lispers go crazy in love with the language.
Still it is a big deal, if you think it through. A good macrologist can write macros that save a lot of effort and time, not to mention LOC. Where a typical (say) Java programmer might say look at the prospect of entering a dozen or so almost-identical patterns in their code and say, "I wonder if I could squeeze this into a single function... no, it would have too many parameters, and how would I handle all the edge cases?", then proceed to do them as cut-and-paste, a competent Lisper would say, 'Hmmn, I'll write a macro to put a special syntax around this, it'll take this this and this to handle the edge cases, but I can do it...', and the whole thing would take half as much code space as the Java version. More effort, but a bigger reward.
I didn't just pull that example out of a hat; I've cursed the lack of macros in conventional languages many times for exactly that scenario. But the problem is, Lisp macros really only work with Lisp's s-expression syntax. True, some languages have a form of macro such as the templates and generics in C++, Java, and C#, but the Lisper sneers at the limitations of these, limitation imposed on - surprise - the use of special-case syntax for common things like loop constructs. It is the simplicity of Lisp - the lack of syntax which drives most programmers away - that give Lisp it's power.
TL;DR - Macros are what separate Lisp from most other languages. Even if you don't like Lisp, at least look into it enough to get the idea of why macros are such a game changer.
Filed Under: well, that was a waste of an hour's writing...
-
most people only know macros from C and assembler
You have a weird definition of "most". Most people know macros because of MS-Office, especially Excel.
-
OK, I hadn't even been thinking in terms of Excel. I don't use it much myself, but you're right, that's where most people get their ideas about macros. I appreciate the correction.
-
Filed Under: well, that was a waste of an hour's writing...
Not a total waste. You've given people here who didn't know about macros another excuse not to use Lisp:
How can I read someone else's code with all those macros in it?
-
Very true, although that's a completely different definition of macro.
-
Sure, LISP macros are great for nerdy-geek programmer dudes, but how do they help me solve actual problems?
You know what helps me solve actual problems? When you use C# to connect to databases, it does connection-pooling by default (where applicable). Because there's no reason not to do it, Microsoft just shrugged and said, "hey why not?" and so it does. That's code that I, as an application developer, don't have to write. When I write my code in C#, my database accesses are just automatically many times faster than other languages, and I didn't have to do shit.
The purpose of programming isn't to wank-around writing "clever" shit. (For the nerdy-geek programmer's definition of "clever", which is pretty much the opposite of the normal person's.) The purpose of programming is to solve problems with computers. If you want to convince me that macros are so great, convince me that they solve programs better.
And, BTW, as a pragmatic person, an article from Reddit saying, "we ditched LISP and went to Python" is worth about 3,000 articles about "hey look at this programming language feature you can wank around with!!!"
-
For me, it all comes down to one thing: Yes, other languages have absorbed some of Lisp's better tricks, but they have left the arcane syntax behind. Lisp may have led the way on some things, but when most people who program in other languages think of it the first thing to come to mind is "Let's insert some parentheses".
As for requiring licensing for programmers, it almost sounds good on the surface. It will hold back progress so much though and will do nothing but depress salaries in the industry. What you would end up with is programmers being the code equivalent of a legal paralegal. They would be doing all the work, but they would be at the behest of those with the certification who sign off on their work. Same goes for engineers. You typically have a bunch of non-certified people working for a Certified Professional Engineer.
Changes would move at the speed of government. As a person who has a construction background, I know exactly how quickly that would work. Anytime we needed to change an elevation because the engineers fucked up, it would take days or weeks to get an answer on whether or not we could do what we needed to do.
As someone brought up before, lots of the best work in this field is started by a group of enthusiasts in a garage or basement somewhere. You would be shutting them out. Wozniak would never have been allowed to do the work he did at the genesis of Apple, under your scenario.
No offense meant, but your idea is not a bad idea...it is the worst idea. It is not a solution looking for a problem. It is a solution that you have to invent a problem for.
-
And, BTW, as a pragmatic person, an article from Reddit saying, "we ditched LISP and went to Python" is worth about 3,000 articles about "hey look at this programming language feature you can wank around with!!!"
For additional funnies, check out the google group where lispers gathered to make a reddit competitor "written in Lisp, as it should have been".
It ended up as you might expect. Some circlejerk activity back in 2005, then 3 years ago...
Nobody worked on a Redit-look-a-like because the Redit idea is dumb
(newsgroups are much better), because it would be dumb to develop a
system nobody would use, because we're busy working or more interesting
or more paying projects. If you're interested in something like redit,
you'd better work on improving gmane to better deal with web forums
(stuff like redit, news.ycombinator.com, etc, so that you can follow
threads with nntp and post answers without having to touch those
horrible user interfaces)....
Because the user interfaces on nntp are more adapted to users. There
are GUI, CLI, emacs, web, and so on, interfaces on nntp. They present
a unified interface for all discussions, instead of a different
interface (web site) for each discussion. Also the threads structure is
more conductive to constructive discussion (and also helps to filter out
flames).Yup.
-
I'm gonna read this post in a bit more detail:
It's also controversial for a few other reasons, though. Lisp macros really are very different, but they also can be really, mind-bendingly complicated to understand.
So they're the Git of programming constructs?
"Mind-bendingly complicated" constructs are great to send to our offshore programmers in Bangalore who barely know what an enum is.
but are harder to work with for more complex macrology.
macrology
nounLong and tedious talk without much substance; superfluity of words.
Hm.
So it's a shitty example, and most of the starting Lispers who are inclined to try to defend the language but don't really know macros well themselves yet get pissed off because the audience can't see what a brilliant, world-changing thing this is, and give up trying to explain it.
Do you think it's possible the audience here is maybe on to something?
Simple: it's a program that writes new programs on the fly.
How does that even work in a world with DEP on every OS on every CPU? So LISP runtimes are either reeeal fucking slow, disable one of the most important security features of your OS, or simply do not work in modern OSes?
It goes beyond what you can do with an ordinary function because it is actually generating new code, before it gets compiled,
Oh, so it's compiled? Like C/C++ macros? Well that solves that problem I guess.
I thought one of the LISP "selling features" was you could just pause your program anywhere, change code or pop in new shit, and then resume it and it still worked. You know, like JavaScript.
'Yeah, but the Lisp compiler/interpreter is much smaller than the one for C++!', says the Lisper, while the audience yawns. Because you can apply this to any language extensions you want. You're dialect doesn't have OOP support? That's a few macros away. You want a special syntax for, say, multi-path random choice? Voila, a macro. You can hack the language itself. And that's why Lispers go crazy in love with the language.
Right; but then you leave the company, and who maintains it? Sounds like LISP is a write-only language, like Perl only more irritating.
Where a typical (say) Java programmer might say look at the prospect of entering a dozen or so almost-identical patterns in their code and say, "I wonder if I could squeeze this into a single function... no, it would have too many parameters, and how would I handle all the edge cases?", then proceed to do them as cut-and-paste,
BTW, a good Java (or C#, or C++) programmer would look at this and say: "oh I know, I'll create a class that handles the 90% case, and subclass it for the 10% cases."
but the Lisper sneers at the limitations of these,
You ain't gonna make any friends by sneering.
-
Yup.
Haha that's epic open source-ery right there.
I don't like or use Reddit myself, but the idea of replicating the entire newsgroup experience on the web was fucking brilliant, and I give them props for coming up with it.
-
Your proposed macro here strikes me as exactly the same as a well defined class in c#. I see no benefit in what you propose, and what a moden language like c# has built in to the language, and significantly baked in to the most prominent ide.
That's not to say there isn't a benefit there, just that I don't see any benefits when compared to modern languages.
And I'll take 10 heaping pounds of syntactic sugar provided in c#3.5/4/4.5, all of which bring a consistent feel to my code and reduce my work.
-
Sure, LISP macros are great for nerdy-geek programmer dudes, but how do they help me solve actual problems?
You know what helps me solve actual problems? When you use C# to connect to databases, it does connection-pooling by default (where applicable). Because there's no reason not to do it, Microsoft just shrugged and said, "hey why not?" and so it does. That's code that I, as an application developer, don't have to write. When I write my code in C#, my database accesses are just automatically many times faster than other languages, and I didn't have to do shit.
Admittedly, this is a feature of the platform, not language. You could make a framework for Lisp (or any other language) that did the same thing.
Now, saying "platform is more important then language" is a valid (and probably correct) position, but that doesn't mean languages themselves can't be discussed and measured on their own merit.
-
Isn't there a CLR Lisp?
-
Admittedly, this is a feature of the platform, not language.
I think of the whole thing holistically. You simply never have C# without the .net standard libraries, even in Mono, so that's one unit of "thing" to compare.
Also device drivers are hardware. #troll
You could make a framework for Lisp (or any other language) that did the same thing.
You could, but I'll bet $50 it doesn't exist.
Now, saying "platform is more important then language" is a valid (and probably correct) position, but that doesn't mean languages themselves can't be discussed and measured on their own merit.
If the platform and language come bundled 100% of the time, they're one single thing. People don't have trouble with that when it comes to Java, so I'm not sure why that would be confusing with C#.
-
Isn't there a CLR Lisp?
If there is, it doesn't count towards my bet. That's cheating.
-
Filed Under: well, that was a waste of an hour's writing...
Nope, I enjoyed it, even if I didn't understand a thing in that code example.
I think this 100% functional syntax is just geared too heavily towards math people. These days, majority of coders aren't. So while we may flirt with functional paradigm, I don't think we will ever accept it the way we did OO.
-
I don't like or use Reddit myself, but the idea of replicating the entire newsgroup experience on the web
Is that what it's supposed to be?
-
cartman82 said:
You could make a framework for Lisp (or any other language) that did the same thing.You could, but I'll bet $50 it doesn't exist.
-
Is that what it's supposed to be?
Certainly seems like that was their plan to me. Their content is about on par with what newgroups were shitting out in their dying years.
-
If there is, it doesn't count towards my bet. That's cheating.
Yup that's the point. You make a Lisp for CLR and suddenly your argument crumbles.
There are better reasons why C# is better than Lisp. Like how you don't need to be a math genius, and yet are able to write better performing and cleaner code than in Lisp.
-
Not to forget, there's C♯ and VB.NET's red-haired stepsister F♯ who also does functional stuff and who was created by MicroSoft themselves.
Filed under: Never heard of anyone who ever used it, though
-
CLSQL uses connection pools.
Aha:
pool
A boolean flag. If T, acquire connection from a pool of open connections. If the pool is empty, a new connection is created. The default is NIL.... I was going to say that proves me right that it didn't pool by default, but only if you pass true (or capital T I guess). But re-reading the documentation there, it's fucking vague as hell and there's no way to tell exactly what happens by default. What does "acquire connection from a pool of open connections" mean exactly? Where does the pool come from? Does it create one, or use an existing one? It says "if the pool is empty, a new connection is created." A single connection, or a new connection pool?
So in any case, I'm keeping my $50.
-
Not to forget, there's C♯ and VB.NET's red-haired stepsister F♯ who also does functional stuff and who was created by MicroSoft themselves.
Filed under: Never heard of anyone who ever used it, though
You know, I started seeing glimpses of it on some twitter feeds. Someone needs to approach these people and give them a good whopping.
-
There are better reasons why C# is better than Lisp. Like how you don't need to be a math genius, and yet are able to write better performing and cleaner code than in Lisp.
@ScholRLEA, are you paying attention? This is the real reason people don't use Lisp.
... I was going to say that proves me right that it didn't pool by default, but only if you pass true (or capital T I guess). But re-reading the documentation there, it's fucking vague as hell and there's no way to tell exactly what happens by default. What does "acquire connection from a pool of open connections" mean exactly? Where does the pool come from? Does it create one, or use an existing one? It says "if the pool is empty, a new connection is created." A single connection, or a new connection pool?
So in any case, I'm keeping my $50.
Good job moving the goal posts while missing the point: It took 10 seconds of looking at google search results to prove you wrong about this.
-
Good job moving the goal posts while missing the point: It took 10 seconds of looking at google search results to prove you wrong about this.
Thanks, I try.
From reading that documentation, I have no idea if LISP pools database connections by default. If you have more evidence, then provide it.
And in any case, I can always squirm out by pointing out that whatever "CLSQL" is, it's not part of LISP itself even according to its own homepage.
-
I'll start with a try for a pedantic dickweed badge. No one has used LISP in about 20 years; Common Lisp is used instead these days. CLSQL is not included in Common Lisp but is the de facto standard. What I mean by that is if you go to a Lisp forum and ask how to connect to a database from Lisp they will tell you to use CLSQL. CLSQL can be installed with a one-line command if you have quicklisp, which is the de facto standard for managing libraries in Common Lisp.
Your additional requirement that the connection pooling be done by default reminds me of the following from my quote file:
I find it weird that people who use* the world's most extensible
programming language have these idiotic discussions on the library
parts of the standard. I suppose that these are the same people who
call the factory to complain when their 21-speed road bike arrived
with the chain positioned on cogs 2-7 -- the rest just learn how to
shift gears and start biking.*Of course, it frequently turns out that the people who initiate these
discussions do not actually program in Lisp. So why are they taken
seriously? This is a great mystery.The point being that if enabling connection pooling takes one line of code, having it be a default doesn't really matter all that much.
