1. The software industry changes rapidly, but you can protect yourself from these changes by creating code that is complicated enough that only you can maintain it.

    Of course you should not engage in obvious bad practices. The good news is that you don't have to. You can follow idiomatic industry practice and stay buzzword compliant with the latest trends, while quietly spreading complexity throughout systems. Better yet, the symptoms will show up not in your own code, but in other code that uses your code, directly or indirectly. You will be a hero as you lead larger and larger teams burning the midnight oil to keep systems alive.

    Practice these principles, and your code will have an infectious complexity that guarantees you will always be needed to maintain it.

    Use OO, and don't forget those setter methods!
    Prefer APIs over data.
    Start with DSLs.
    Always connect (and never enqueue).
    Create abstractions for information.
    Use static typing across subsystem boundaries.
    Put language semantics on the wire.
    Write lots of unit tests.
    Leverage context.
    Update information in place.

    Stuart Halloway is a founder and President of Relevance. He is a Clojure committer, and a developer of the Datomic database.

    Stuart has spoken at a variety of industry events, including StrangeLoop, Clojure/conj, EuroClojure, ClojureWest, SpeakerConf, QCon, GOTO, OSCON, RailsConf, RubyConf, JavaOne, and NFJS.

    Stuart has written a number of books and technical articles. Of these, he is most proud of Programming Clojure.

    Seen at Reaktor Dev Day 2013

    # vimeo.com/77199361 Uploaded 13.9K Plays 8 Comments
  2. Clojure is a powerful dynamic language that compiles to many target environments, including the JVM, JavaScript, and the CLR. In this talk, you will learn how to think in Clojure, and why you should want to.

    Clojure encourages functional style with persistent data structures, a rich library of pure functions, and powerful processing support via the seq and reducer abstractions. Clojure implements a reference model for state, where references represent atomic successions of values, and change is encapsulated by value and reference constructors. This reference model is more substantive and suitable to application development than individual techniques such as Software Transactional Memory (STM) or actors.

    The most important single principle behind Clojure is simplicity. Clojure's abstractions are simple and orthogonal. A la carte polymorphism, careful support for names and namespaces, the reference succession model, and a wide selection of small, composable protocols make Clojure programming swift, surgical and accurate.

    Clojure's expressiveness does not mean that you have to compromise on power. It is an explicit design goal of Clojure to provide access to the power of the underlying platform, and for programmers never to have to "drop down" to the platform level for performance-sensitive work.

    # vimeo.com/68375202 Uploaded 9,303 Plays 1 Comment



Browse This Channel

Shout Box

Heads up: the shoutbox will be retiring soon. It’s tired of working, and can’t wait to relax. You can still send a message to the channel owner, though!

Channels are a simple, beautiful way to showcase and watch videos. Browse more Channels.