docs/new-to-clojure.html

<!DOCTYPE html PUBLIC ""
    "">
<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}
  gtag('js', new Date());

  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
<h2>About Clojure</h2>
<p>LISP stands for List Processing and it was originally designed by John McCarthy
around 1958.  It was the first language with a garbage collector making it the first
truly high level language assuming you don't consider Fortran a high level language.
Here is Dr. McCarthy's <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a>
and for a much better intro than I can give please see
<a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
<p>Time passed and along came a man named Rich Hickey.  Making a long story short, Rich was
working in a variety of languages such as C++, Java, and C# when he did a project in
Common Lisp and was hooked.  There are many YouTube videos and documents that Rich has
produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a>
is one I found very compelling.  If you enjoy that video, don't stop there; Rich has
many interesting, profound, and sometimes provocative things to add to the conversation.
For more about his reasoning behind Clojure, please check out his
<a href="https://clojure.org/about/rationale">rationale</a>.</p>
<p>My perspective is closer to <a href="http://blog.cleancoder.com/uncle-bob/2019/08/22/WhyClojure.html">Uncle Bob's</a>.</p>
<p>To address the parenthesis, we need to talk about
<a href="https://en.wikipedia.org/wiki/Homoiconicity">homoiconicity</a>.  LISPs are part of a
subset of languages that build themselves out of their own data structures so that when
you type symbols into a file or repl, you get back a data structure of the language
itself.  This means that several parts of the programmers toolbox can be simpler and you
can load a file as data, transform it, and then execute some portion of it all without
leaving the language.  This isn't something you will really need to understand today,
but the point is that the look and structure of the language is a sweet spot to make it
more of middle ground between what a human and a machine can understand.</p>
<p>The fallout from having a language that is both a language and a data structure is that
you can extend the language without needing to change the compiler.  For example, the
very first standardized 'object oriented programming' system was
<a href="https://en.wikipedia.org/wiki/Common_Lisp_Object_System">CLOS</a>, or Common Lisp Object
System.  This was implemented on top of Common Lisp with no updates to the compiler
whatsoever.  In Clojure, we have been able to add things like an
<a href="https://github.com/clojure/core.async">async library</a> or
<a href="https://clojure.org/reference/refs">software transactional memory</a> without changing the
compiler itself because we can extend or change the language quite substantially at compile
time.</p>
<p>Clojure is a deeply functional language with pragmatic pathways built for mutation.  All
of the basic data structures of Clojure are immutable.  Learning to program in a
functional manner will mean learning things like <code>map</code> and <code>reduce</code> and basically
re-wiring how you think about problems.  I believe it is this re-wiring that is most
beneficial in the long term regardless of whether you become some functional programming
God or just dabble for a while.</p>
<p>Many systems, regardless of language, are designed in a functional manner because
properties like <a href="https://en.wikipedia.org/wiki/Idempotence">idempotency</a> and
<a href="https://en.wikipedia.org/wiki/Referential_transparency">referential transparency</a> make
it easier to reason about code that you didn't write.  That being said, Clojure doesn't
force you to write functional code all the time as it is mainly a pragmatic language.
You can easily write mutable code if you like.</p>
<p>For the web, Clojure has a <a href="https://clojurescript.org/">version</a> that compiles to
JavaScript so that you can write one language both server and front end side.  Many
Clojure projects are just one repository and one artifact that when run produces both
the server and client side of the equation.  Another important usage of the
Clojurescript is mobile application development using frameworks like
<a href="https://www.upwork.com/blog/2018/11/developing-react-native-applications-in-clojurescript/">React Native</a>.
Clojurescript is truly one of Clojure's greatest strengths and one that the Clojure
community has strongly embraced.</p>
<p>No talk about Clojure would be complete without giving major credit to its excellent
REPL support.  One important aspect of the Clojure REPL is that you can see all of
complex nested datastructures easily without needing to write <code>toString</code> or <code>__str__</code>
methods.  Because of this visibility advantage a common way to use Clojure is to model
your problem as a transformation from datastructure to datastructure, testing each stage
of this transformation in the repl and just letting the REPL printing show you the next
move.  Programming with data is often just easier than programming with objects and
debugging data transformations is far, far easier than debugging a complex object graph.</p>
<h2>Learning Clojure</h2>
<p>There are in fact many resources to learn Clojure and here are some the community
recommends:</p>
<h3>Books/Courses</h3>
<ol>
<li><a href="https://www.braveclojure.com/clojure-for-the-brave-and-true/">Clojure for the Brave and True</a></li>
<li><a href="https://practicalli.github.io/clojure/">Practicalli</a></li>
<li><a href="https://www.amazon.it/dp/B00YSILGWG/ref=dp-kindle-redirect?_encoding=UTF8&amp;btkr=1">Clojure for Data Science</a></li>
<li><a href="https://www.amazon.it/dp/B00HUEG8KK/ref=dp-kindle-redirect?_encoding=UTF8&amp;btkr=1">Functional Programming in Scala and Clojure</a></li>
</ol>
<p>Practicalli has a page devoted purely to resources on learning Clojure at whatever level
you are so if these recommendations do not speak to you please review their
<a href="https://practicalli.github.io/clojure/reference/books.html">books page</a>.</p>
<h3>Learn by Writing Code</h3>
<ol>
<li><a href="https://github.com/functional-koans/clojure-koans">Clojure Koans</a></li>
<li><a href="https://github.com/lspector/clojinc">clojinc</a></li>
<li><a href="http://clojurescriptkoans.com/">Clojurescript Koans</a></li>
<li><a href="http://www.4clojure.com/">4Clojure</a></li>
</ol>
<h3>IDEs/Editors</h3>
<p>There are many more IDEs available than listed here; these ones are just very popular:</p>
<ol>
<li><a href="https://marketplace.visualstudio.com/items?itemName=betterthantomorrow.calva">Calva</a></li>
<li><a href="https://cursive-ide.com/">Cursive</a></li>
<li><a href="https://medium.com/@jacekschae/slick-clojure-editor-setup-with-atom-a3c1b528b722">Atom</a></li>
<li><a href="https://cider.mx/">emacs + cider</a></li>
<li><a href="https://www.vim.org/scripts/script.php?script_id=4978">vim + fireplace</a></li>
</ol>
<p>One thing to be sure of, regardless of IDE, is to use some form of
<a href="https://shaunlebron.github.io/parinfer/">structural editing</a>.  All the better IDEs
have it; all the IDEs listed here have it, and I personally really struggle without it.
When I have a form of <a href="https://wikemacs.org/wiki/Paredit-mode">structure editing</a>, however,
I can move code around much faster than I can in Java, Python, or C++. This is another
benefit of the homoiconicity that we spoke earlier in that we can transform the program easily
because it is just a data structure and this includes editor level transformations and
analysis.</p>
<h2>Off We Go!</h2>
<p>Clojure is an amazing language.  It is really rewarding on a personal level because it
is tailored towards extremely high individual and small group productivity.  But this
power comes with some caveats and one of those is that learning Clojure takes time and
patience.  The community is here to support you, however, so check us out:</p>
<ul>
<li><a href="https://clojurians.slack.com">Clojurians Slack</a></li>
<li><a href="https://clojurians.zulipchat.com/">Clojurians Zulip</a></li>
<li><a href="https://www.reddit.com/r/Clojure/">r/Clojure reddit</a></li>
<li><a href="https://www.reddit.com/r/Clojurescript/">r/Clojurescript reddit</a></li>
<li><a href="https://clojureverse.org/">Clojureverse</a></li>
</ul>
</div></div></div></body></html>