It's certainly something I would like to add to counterclockwise.

If only paredit's code was written in clojure, it could have been more
easily reused by enclojure, La Clojure and counterclockwise ! :-(



2009/12/19 Avital Oliver <avi...@thewe.net>

> It seems that noone has brought up the amazing paredit mode for emacs which
> gives you keyboard commands for s-expression structure manipulation. It also
> makes sure you never get your close parenthesis wrong. I use it and can't
> imagine writing any medium+-complexity code without it.
>
> On Dec 19, 2009 6:11 AM, "ajay gopalakrishnan" <ajgop...@gmail.com> wrote:
>
> Hi,
>
> I've a different take on the entire thing. Based on my experience I have
> realized the following:
>
>    1. A lot of software engineers do not have a CS background. Out of
>    them, many joined this field for the fun of coding and are willing to learn
>    new things. I know many like that. However, I feel a large majority of them
>    are those for whom Java is probably what Software development basically is.
>    (This has been a boon and bane of Computer Science. It reduces the barrier
>    to entry, but also prevents them from appreciating the true beauty. Many 
> can
>    code a web application, thanks to Rails, Hibernate and the like without 
> even
>    having an idea of what B-tree is) Everything begins and ends with Java. 
> They
>    don't even know anything about C/C++.
>    And I think it would be foolish to assume that Clojure acceptance will
>    reach critical mass unless it is accepted by this group of people.
>    2. Second issue is Bosses (higher-ups) and convincing them is hard.
>    Language features and the beauty of Lisp is not going to convince them. The
>    biggest problem is I think when they realize that they will have to loose
>    all the Imperative programming skills they have acquired all over these
>    years and now they will be on equal footing with the rest when it comes to
>    Functional programming experience.
>    3. Sad as it is, most of the work gets done by Copy-paste work and
>    unless there is a online cookbook type thing, people will find it hard.
>
> Unless Clojure (not just Clojure, any functional programming language)
> reduces this barrier to entry for both the non-core developers and the
> Bosses, I think any FP language will find it hard.
> Now, if we want Clojure to get accepted fast, I think we must be eager to
> reduce this barrier to entry. Just saying that "If you can program in LISP"
> then you can code Clojure is not a very smart answer. Similarly saying "get
> used to parenthesis" is not a smart answer either.
>
> *It's really wrong to think that if they do not accept Clojure they are
> doomed. The users have a higher hand and if not Clojure, new languages will
> keep on being built until some language gets accepted by all. *
>
> I think what needs to be done is the following:
>
>    1. In LISP like languages, Parenthesis is a non-issue as long as code
>    is properly indented. And hence *strictly following indenting rules*while 
> defining functions/Macros etc. is really really crucial. Hence my next
>    point.
>    2. Excellent IDE indenting support for code Indentation. I have tried
>    Enclojure and it is good. But what I find is difficult for the LISP newbie
>    is deciding when to put code on the new line for function arguments and all
>    that. I know that there are rules for that (most Scheme like), but frankly
>    speaking, people have become very lazy and wouldn't waste time reading the
>    indenting rules, especially when the other Haskell,F#, Scala camp boasts to
>    address the same issues and say that we do it all without a lot of
>    parenthesis. *So in short, Can we do something in the IDE to make
>    Clojure code indentation a totally no-brainer?*
>    Perhaps Enclojure must show some *placeholders* properly indented based
>    on whether it is defmacro, defn or fn etc and the developer just fills it
>    up. This would be an excellent aid in promoting LISP indenting standards.
>    Overtime, once Clojure is widespread people will automatically start
>    doing it correctly.
>    3. A nice and good article written by Clojure folks that highlights how
>    to transition from the OOPS thinking to Functional thinking.
>       1. Just saying "Practice coding recursively" does not help at all.
>       Even core CS people do not use recursion for every thing these days.
>       Students have OS labs, Networking Labs and projects but everyone knows 
> that
>       it does not involve much of recursion and all - just a plain sequence of
>       operations, that's all. At most 2-3 courses on Algorithms is where they 
> use
>       Recursion heavily.
>       2. I think the keyword "let" and the pipeline is very understated.
>       "let" is the single most important thing that makes this transition 
> easy.
>    4. Have an article that has some decent functions in it and each should
>    have an explanation of how an experienced Clojurian/LISPian would read this
>    code mentally. Just write it as a transcript. Or may be a Screen cast.
>    5. Have a cookbook like article for all common tasks.
>    6. Explain how idiomatic code looks like in Clojure. I feel experienced
>    Lispers can help in this. It feels very scary when an experienced OOPS
>    developer knowing all idiomatic code in OOPS does not know anything in 
> LISP.
>    I'm afraid to say that this feeling of shame must be prevented. After all,
>    writing idiomatic LISP code is not rocket science. It is just lack of
>    experience
>
> *I personally feel that Clojure has enough of nice features.* All that is
> left to do is to make the transition easier. Although it may seem less
> technical and less interesting to the geeks, it is important to realize that
> all coders are not geeks and not everybody behaves rationally. Looks,
> presentation and ability to lure people also matters. After all, looks and
> ease in *every* way is an integral part of a Programming Language.
>
> Finally, comments like "doing XYZ will encourage them to write sloppy code"
> is not good. Nobody likes to write sloppy code. They do it because writing
> good code is very hard in the language or the IDE does not support it.
>
> A language need not be very good to be a success. A lot depends on the IDE
> support. It is known to everybody that most of the Java code is written in
> IDE like Eclipse only. And Eclipse goes a long way in reducing the
> boilerplate code, thus reducing a flaw in the Java language. Similarly
> Enclojure and Counterclockwise support be just splendid. Just saying "use
> Slime/Vimclojure" does not help again.
>
> My 5 cents. it is too long for 2 cents.
>
> Thanks,
> Ajay G
>
> On Fri, Dec 18, 2009 at 9:28 PM, Sean Devlin <francoisdev...@gmail.com>
> wrote: > > Look, Clojure...
>
>  --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com<clojure%2bunsubscr...@googlegroups.com>
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Reply via email to