LispCast

I would suggest The Little Schemer to understand the concepts of Lisp/Scheme. I would read and digest this before any other lisp book. The book appears to be an easy read but it is not. Practical Common Lisp lives up to its name and has some very good examples/projects intermixed with lessons. Be prepared to spend a lot of time manipulating, breaking down and refactoring code (for macros use macroexpand-1). This is exactly what you need to do when you get that lost feeling. The best thing about lisp/scheme is that the interpreter is always available to you to test and environments like slime or allegro IDE which allow interaction between the editor and interpreter. Also checkout lispcast (http://www.lispcast.com/)

Location: New Orleans, LA Remote: Yes. Willing to relocate: Negative. Technologies: Clojure, ClojureScript, Haskell, CSS, HTML, React, Om, PostgreSQL Email: [email protected] Website: http://lispcast.com/ Github: https://github.com/ericnormand Specialities in analyzing a problem from the business perspective and delivering a solution to those needs. Functional programming, simple, clean code. Can help train new hires in good functional skills. Love building interactive systems. I've worked for startups for the last 4 years. I know what execution means. I wear many hats, from ops to dev to design to customer service. If you want someone you can have a conversation with about your business and have a working solution delivered, hire me. I'm looking for a place where I can thrive. Looking for full-time/part-time contract work; must be remote or in New Orleans. Email me and we'll get started.

Great book. Great podcast by him as well: https://lispcast.com/category/podcast/

Eric Normand has a great podcast episode where he talks through the paper, summarizing and commenting on it in a way that targets a more general audience. https://lispcast.com/can-programming-be-liberated-from-the-von-neumann…

This is the best argument I've seen for dynamic types beyond the prototyping phase: https://lispcast.com/clojure-and-types/ Not sure if I'm 100% won over, but it makes some good points, particularly the section about JSON. Using TypeScript at work, one of the most painful (yet quite common) things is dealing with foreign JSON from an API, which is sometimes just... wrong. And then all our carefully-typed code falls to pieces. The argument is that in a language like Clojure you can skip pretending to make guarantees about messy external data, and trade that for simple and elegant traversal code. Probably this is why dynamic languages tend to gravitate towards "glue code" use cases while static types gravitate towards insulated systems with minimal surface area to the outside world (compilers, anyone?).

So, I love me some ML-style languages, including Haskell, but I've also come to think that Rich Hickey is right about the real problems of business programming not being well solved by digging in on things like static typing. For example, pattern matching against static types is cool, but, compared to pattern matching directly against data, Clojure-style, is even cooler. One makes the code a bit more concise and readable, but not necessarily a whole lot more maintainable. The other takes one of the more annoying and error-prone portions of my (say) Java code and renders it far more manageable. There's a recent LispCast that talks about this a bit: https://lispcast.com/what-is-data-orientation/

A closely allied idea to "never rewrite" is "you can always refactor shit into gold." For the first ten years after reading the Refactoring book I believed the second claim was true. Don't get me wrong, I think you can make great improvements to a code base with Refactoring. But sometimes a re-design really is needed. Eric Normand addresses one facet of this by saying "you can't refactor Aristotle to Newton": https://lispcast.com/building-composable-abstractions/

The original article doesn't make much sense to me either. It's just a weird rant. I love Clojure and many of its libraries, but I think there are some aspects inhibiting its growth. Here they cover a few of these aspects: http://www.lispcast.com/cognitect-clojure It worries me a bit, since I would really like to have a practical Lisp that is on par with other mainstream languages in terms of tools, libraries and community. Clojure is quite healthy now, but some items need to be addressed in order not to fall behind. I'm also quite enthusiastic about Racket getting to run on top of Chez Scheme, which may give it a bit of momentum. Besides, Clasp, with its LLVM capabilities, is the most promising Common Lisp to me right now. Sadly, it's mostly one-man project and the whole Common Lisp scene is a bit stagnant.

Anki is great. I've used it to learn the 100 most common Clojure expressions. You can get the Anki file by signing up for the newsletter at http://www.lispcast.com/100-most-used-clojure-expressions

Anonymous said it best: http://www.lispcast.com/drupal/node/29#comment-69

Fundamental difference between static and dynamic: static typing disallows writing a certain set of perfectly valid programs while also having the advantage of disallowing many invalid programs. So the question becomes: how badly do you want to work in that space that is not permitted by static systems? And that space is where your data itself is highly dynamic. When you just want to represent data as maps, do generic operations on maps, then spit out more maps back to something else. This description applies to many many real world systems, particular in the more business-type domains. Another space where dynamic really shines is dealing with relational data in a relational way. Relations are just sets of maps, the most natural thing in the world to work with dynamically. In a dynamic language I can just write code that peaks into the map, transforms certain fields, then passes the whole thing on down the line. I don't care what combination of selects and joins got me that relation, and in reality there will be many, I want to reuse my functions regardless. Although this is where more structural type systems can help ease the pain over nominal type systems. I feel like this is a great blog post talking about the downsides of static typing in a real world system: https://lispcast.com/user-wizard-scenario/. I appreciate that the author has real world experience with both Haskell and Clojure and comes from that perspective. Ultimately I'd say that if a program can be…

Not who you are responding to, but the common idea that static types are all win and no cost has become very popular these days, but isn't true, it's just that the benefits of static typing are immediately apparent and obvious, but their costs are more diffuse and less obvious. I thought this was a pretty good write up on the subject that gets at a few of the benefits https://lispcast.com/clojure-and-types/ Just to name some of the costs of static types briefly: * they are very blunt -- they will forbid many perfectly valid programs just on the basis that you haven't fit your program into the type system's view of how to encode invariants. So in a static typing language you are always to greater or lesser extent modifying your code away from how you could have naturally expressed the functionality towards helping the compiler understand it. * Sometimes this is not such a big change from how you'd otherwise write, but other times the challenge of writing some code could be virtually completely in the problem of how to express your invariants within the type system, and it becomes an obsession/game. I've seen this run rampant in the Scala world where the complexity of code reaches the level of satire. * Everything you encode via static types is something that you would actually have to change your code to allow it to change. Maybe this seems obvious, but it has big implications against how coupled and fragile your code is. Consider in Scala you're parsing a document into a…

Oh yeah GHC error messages are bad. Notice how I said Elm instead of Haskell at the end :). One of the things I dislike about GHC is the wasted potential there that's evident in the compilers for newer languages like Rust, Elm, and Purescript when it comes to errors. I haven't found a good way of switching on ex-info generated exceptions. I usually end up having to do string matching or key searching both of which feel brittle. There's ways of following patterns within the boundaries of my own codebase (e.g. a custom key I know will always be there), but that doesn't play well with the ecosystem at large because there aren't well established conventions around what's what. I don't want to come off as saying there's a fundamental reason why Clojure couldn't have better error handling. It's not a language level thing but rather a community thing. I think Python is a good example of where the community has coalesced around using specific error types even though it's a dynamic language. I totally agree with doing validation at the edges of the program and try to enforce that in whatever language I'm writing in. I think this is a common misconception about statically typed FP that shows up in e.g. Rich Hickey's talk about types. It's quite rare for things like `Maybe` or `Either` to actually show up in your data structure (e.g. Rich Hickey's SSN example). You usually end up bubbling the error to the top of your module and deal with it at a module level. The type is just there…

Well, the three key aspects, in my preference order, are: 1. Server repl with editor integrated clients. So your text buffers in your favorite editor is the repl. Look at the gifs here https://atom.io/packages/proto-repl to give you an idea for it. 2. Reifed language constructs. You can read about it here http://www.lispcast.com/reification . An easy example is if you have fn A depend on B. If you change B and call A, A will use new B. That's because the information is still availaible at runtime for A to figure out the latest version of B when calling it. 3. Functional programming / emphasis on small independent code blocks that compose. This is where you hear things like immutability, functions that take functions, purity, side effect free, managed references, etc. Basicly state in Clojure is hard to corrupt. That means if you alter state in your repl, it rarely messes up the full state, allowing you to keep working long sessions with your app state still being valid and usable. I don't have a link for #3. So I'll give an example. Say you have a map you want to add data too. Say this map is read by something else, but you want to try adding something deeply nested to it. In Clojure, you can try as much as you want, experiment until you succeed to mold the map the way you wanted. The other thing reading the map never saw any of your changes, because it sees an immutable view of it. So after your done, if you use that other thing, it'll still work, because you didn't…

> Questions such as yours makes me realize that a lot of go developers don't even understand what is the purpose of generic programming. While this sounds a bit condescending I know exactly what you mean. There seems to be some sort of "language barrier" (where the language is programming language concepts) between developers from different backgrounds. Go is currently used in a lot of successful projects, so it gets new developers from lots of places and they are failing to communicate adequately about the language itself. I see three main groups (there may be more!): a) People who come from C and other lower-level languages: They are introduced to memory-safety, keep a type system that they already know and are comfortable with and in addition get a polished, well-integrated toolchain. b) People who come from Python, Ruby and other "untyped" scripting languages. These are introduced to native code (wow! fast!), a type system that isn't expressive - but sufficient (and more than they had before), and the same toolchain experience. c) People who come from higher-level, safer languages including (but not limited to) Java, Haskell, C# and so on. These developers for the most part already had well-functioning toolchains, but they are "stepping down" to a language that is less expressive (okay, for Java-people YMMV greatly) and often end up frustrated. Now you get conflicts when the c-people have discussions like this with the a/b-people and nobody is happy. There's an…

There is a really interesting link between React and Clojurescript in the Om library. There is a great blog entry about Clojurescript and OM by David Nolen "The Future of Javascript MVCs". http://swannodette.github.io/2013/12/17/the-future-of-javascript-mvcs/ The claim by David is that, "ClojureScript om based TodoMVC looks 30-40X faster than Backbone.js TodoMVC, which means other JS frameworks left completely in the dust". https://twitter.com/swannodette/status/412033352699744256 There is some more discussion of Clojurescript and Om on Fredrik Dyrkell's blog on "A slice of React, Clojurescript and Om". The big idea with Om is to simplify idiomatic state management with Clojurescript’s immutable datastructures, while still getting all the performance. He has some nice comparisons with JavaScript and ClojureScript side by side. http://www.lexicallyscoped.com/2013/12/25/slice-of-reactjs-and-cljs.ht… On Eric Normand's blog post "React: Another Level of Indirection" he talks about how there are four pieces of the puzzle in ClojureScript Web Development - and Om is the final missing piece: Problem: Global state management Solution: Atoms and persistent data structures Problem: Client-server communication Solution: EDN (also solved pretty well by JSON) Problem: Callback hell Solution: core.async Problem: Stateful DOM Solution: React http://www.lispcast.com/react-another-level-of-indirection Form your own opinion of course, but these are some interesting claims.

Be careful, that's just one way of looking at things. See https://lispcast.com/church-vs-curry-types/ or https://en.wikipedia.org/wiki/Simply_typed_lambda_calculus#Intrinsic_v… > A type is a (possibly infinite) subset of all the possible values that can be provided as input to a program, or all the possible results a program can produce. What you are describing are 'extrinsic types. There are also 'intrinsic types'. Btw, types don't have to be sets at all. (Nor are they all isomorphic to sets. Some types describe things bigger than sets.)

related article on nil punning: https://lispcast.com/nil-punning/

Once a month, I find myself wishing Clojure had static typing, before dramatically rediscovering why not having it can be such a relief. The reasons for this are expressed much more articulately than I can here: https://lispcast.com/clojure-and-types/ ... Personally, for the kind of work that I do, I've found clojure's compromises make my life on net easier, and my code, on net, more reasonable.

Clojure stack traces are usually long and somewhat leaky, they are hard to read without (and sometimes even with) preexisting knowledge about Java / JVM / Clojure implementation details. https://ioavisopretty.readthedocs.io/en/v0.1.34/exceptions.html https://lispcast.com/clojure-error-messages-accidental/

I was expecting a nice treatise on something like this topic: https://lispcast.com/nil-punning/

The original article (which has been flag-killed) was pretty poor, but included this link in the comments: http://www.lispcast.com/cognitect-clojure

indeed, there has been a small essay on this: http://www.lispcast.com/object-oriented-vs-functional-duals

I guess for #2 you didn't get a chance to try out Schema? (Now at https://github.com/plumatic/schema) Or if so, I wonder what you found lacking in it? http://www.lispcast.com/clojure.spec-vs-schema does a good job highlighting some differences..

I found this article[0] a pretty enlightening tour of how SOLID principles don't require traditional OO. You might find it useful in transitioning - it explains how each of these concepts maps onto idiomatic Clojure. [0]http://www.lispcast.com/solid-principles-in-clojure

As an example there's an essay at http://www.lispcast.com/solid-principles-in-clojure which elaborates on SOLID OO design in Clojure and provides some code examples. For example there's a pretty clear example of the right way to apply SRP to a functional paradigm. I'd interpret it as you need SOLID to do successful OO (required but not sufficient), but using as much SOLID as reasonably possible under any paradigm also happens to result in good/better software. In that way there can be a lot of confusion about what is OO and what is merely usually found nearby OO but isn't OO specific.

He explain his intention was another thing, and this post make it more clear, I think: http://www.lispcast.com/two-kinds-of-bootstrapping

Another way to look at it is that the "uni-typed" pejorative assumes that types are intrinsic to the semantics of a language. Optional type systems reflect the reverse -- that types are an extrinsic feature that should be taken care of by an external library, potentially allowing the choice between multiple competing type checkers or no type checker at all. http://www.lispcast.com/church-vs-curry-types

I also like test driven development. 6 reasons to develop your tests first: http://www.lispcast.com/drupal/node/6

related: https://lispcast.com/are-monads-practical/