Clojure Small Intro

1 like605 views

This document provides an overview of the Clojure programming language. Some key points: 1) Clojure is a Lisp dialect that runs on the Java Virtual Machine (JVM), allowing for concurrent and dynamic development. 2) In Clojure, everything is treated as data - code is represented as regular data structures like lists and maps rather than hardcoded syntax. 3) Clojure favors immutable, persistent data over mutable variables. This simplicity allows for easy parallelization and avoids common bugs from side effects.

Clojure

John Vlachoyiannis
@jonromero
jon@emotionull.com
Http://jon.is.emotionull.com

“Lisp is worth learning for the profound
enlightenment experience you will have
when you finally get it; that experience will
make you a better programmer for the rest
of your days, even if you never actually use
Lisp itself a lot."

Eric S. Raymond, "How to Become a
Hacker".

“LISP stands for: Lots of Insane Stupid
Parentheses”

Anonymous

LISt Processing
LIS
● Second oldest high-level language (first is
Fortran)
● Code as Data (Homoiconic)
● Perfect for Domain-specific languages
(DSL)
● Exploratory programming

Clojure
● Lisp in JVM
● Concurrent programming
● Dynamic Development (REPL)
● Lazy sequences
● No side effects (almost)

(println "Hello World")

function argument

(println "Hello World")
list

symbol string

● Integers – 1234567891234
● Doubles – 3.14. BigDecimals – 3.14M
● Ratios – 22/4
● Strings – '”foo”, Character – a b c
● Symbols – foo, Keywords :foo
● Booleans – true false, Null – nil
● Regex patterns – #”[a-zA-Z0-9]|

Data structures
● Lists
(1 2 3 4), (foo bar baz), (list 1 2 3)
●

● Vectors

[1 2 3], [foo bar], (vector 1 2 3)
●

● Maps

{:a 1 :b 2 :c 3}
●

● Sets

● #{foo bar}

“It is better to have 100
functions operate on one data
structure than to have 10
functions operate on 10 data
Structures.”

Alan J. Perlis

clojure might be a better
java than java

public class StringUtils {
public static boolean isBlank(String str) {
int strLen;
if (str == null || (strLen = str.length()) == 0) {
return true;
}
for (int i = 0; i < strLen; i++) {
if ((Character.isWhitespace(str.charAt(i)) ==
false)) {
return false;
}
}
return true;
}
}

public class StringUtils {
public isBlank(str) {
if (str == null || (strLen = str.length()) == 0) {
return true;
}
for (i = 0; i < strLen; i++) {
if ((Character.isWhitespace(str.charAt(i)) ==
false)) {
return false;
}
}
return true;
}
}

public isBlank(str) {
if (str == null || (strLen = str.length()) == 0) {
return true;
}
for (i = 0; i < strLen; i++) {
if ((Character.isWhitespace(str.charAt(i)) == false))
return false;
}
}
return true;
}

public isBlank(str) {
if (str == null || (strLen = str.length()) == 0) {
return true;
}

every (ch in str) {
Character.isWhitespace(ch);
}
return true;
}

public isBlank(str) {
every (ch in str) {
Character.isWhitespace(ch);
}
}

(defn blank? [s]
(every? #(Character/isWhitespace %) s))

Clojure vs Java code
● Side-effect free ● Error prone
● Easy to (unit) test ● Not so easy
● Lazy collection ● Only one element
● Any element ● Only with chars
● Slower ● Faster
● Data manipulation ● If/for/while code
● Exploratory ● Design Is Law

Clojure is a functional language
● Functions are first-class objects
● Data is immutable
● Functions are pure

● Simple: no loops, variables or mutable
state
● Thread-safe: no locking
● Parallelizable: map/reduce anyone?
● Generic: data is always data
● Easy to test: same input, same output

user=> (println "hello world")
| hello world
-> nil

user=> (defn hello [name]
(str "Hello, " name))
#'user/hello

(defn greeting
"Returns a greeting of the form 'Hello, username.'"
[username]
(str "Hello, " username))

user=> (doc greeting)
-------------------------
exploring/greeting
([username])
Returns a greeting of the form 'Hello, username.'

(defn is-small? [number]
(if (< number 100)
"yes" ))

(defn is-small? [number]
(if (< number 100)
"yes"
"no" ))

Solving problems
● Experiment with the problem
● Create your data structures
● Data transformations
● Write code that writes code for you
(macros)
● Create a mini language (a DSL)

Java in Clojure

java new Widget(“foo”)

clojure (Widget. “foo”)

java dialog.show()

clojure (.show dialog)

Tools
● Emacs + SLIME
● ViMClojure
● Enclojure + Intellij IDEA
● Counterclockwise + Eclipse
● Leiningen

Is another, simplier way to solve problems

This document provides an overview of the Kotlin programming language. Kotlin is a statically typed language that runs on the JVM and has design goals of being concise, safe, interoperable, and tool-friendly. It aims to mitigate weaknesses from Java like boilerplate code and unsafe nulls. Key features discussed include null safety, data classes, higher-order functions, lambdas, and functional-style programming with collections. The document also provides code samples and compares Kotlin's source code organization and packages to Java.

Clojure introBasav Nagur

The code example shows 10 threads concurrently manipulating shared data of 100 vectors with 10 numbers each, by randomly swapping two positions in two random vectors using Clojure's Software Transactional Memory (STM) to ensure consistency across 100,000 iterations per thread, without any numbers getting lost due to the transactions. It initializes the vectors, defines a swap and report function, runs the threads concurrently swapping values, and reports the results.

Scala taxonomyRadim Pavlicek

The Ring programming language version 1.5.2 book - Part 6 of 181Mahmoud Samir Fayed

The document provides an overview of the Ring programming language and highlights new features in version 1.5. Key points include: - Ring is a dynamic and weakly typed scripting language that uses lexical scoping and allows dynamic typing. - New applications like a video player, music player, and Windows startup manager were added. - Libraries for graphics, web development, objects, and debugging were improved. - The virtual machine was enhanced with function tracing and an interactive debugger. - Syntax was made more flexible and a type hints library was added.

Yin Yangs of Software DevelopmentNaveenkumar Muguda

This document discusses various Yin-Yang concepts in software development, including: - Effort and knowledge, theory and practice, design for manufacturing and design for assembly represent opposing yet interconnected concepts. - Programs (E-programs) built on simpler programs (S-programs) balance ease of use and performance. - Designing for both short-term efficiency and long-term evolvability requires balancing opposing priorities. - Many software development processes involve balancing logical thinking with creative control, and reducing complexity through modularity.

JavaScript Data TypesCharles Russell

The document provides an overview of JavaScript data types, emphasizing its weakly typed nature and detailing the six types: boolean, number, string, null, undefined, and object. It explains the behavior of the typeof operator, particularly in relation to null and undefined, as well as the dynamic and mutable nature of objects in JavaScript. Additionally, it covers various characteristics of numbers and strings, including methods and representations important for developers.

05. haskell streaming ioSebastian Rettig

Tour de Jackson: Forgotten Features of Jackson JSON processorTatu Saloranta

This document provides an overview of Jackson, a popular Java library for processing JSON. It discusses Jackson's basic features for reading, writing and binding JSON to POJOs. It also covers some lesser known advanced features like polymorphism handling, object identity, extensibility through modules, and value conversions. The document focuses on "forgotten features" like MrBean for abstract type materialization, Smile for binary JSON encoding, mix-in annotations, and dynamic properties through @JsonAnySetter/@JsonAnyGetter annotations.

The Ring programming language version 1.8 book - Part 7 of 202Mahmoud Samir Fayed

Ring 1.8 includes several new features and improvements such as better performance, new applications like Find in Files and String2Constant, more 3D samples, compiling on Manjaro Linux, updated libraries, and notes for extension creators. Key updates include 10-100% faster performance, a Find in Files application, a String2Constant tool to convert code to use constants, a StopWatch application, improved Form Designer, RingQt, and code generator for extensions. The release provides better compiler, virtual machine, and overall performance.

Pune Clojure Course OutlineBaishampayan Ghose

The document discusses Clojure, a programming language created by Rich Hickey, emphasizing its functional programming features, concurrency capabilities, and integration with Java. It highlights the language's flexibility with data structures, such as lists, vectors, and maps, as well as its dynamic development environment. The text also mentions various libraries and communities associated with Clojure, pointing to its extensive applications and resources for developers.

Learning groovy -EU workshopadam1davis

Head First Java Chapter 1Tom Henricksen

Introduction to Groovy (Serbian Developer Conference 2013)Joachim Baumann

The document provides an overview of the Groovy programming language. It discusses key features of Groovy including that everything in Groovy is an object, its support for closures as first-class functions, and dynamic typing. Examples are given demonstrating how Groovy code is more concise than Java for common tasks like XML parsing, building a simple web server, and creating domain specific languages.

Python internals and how they affect your code - kasra ahmadvandirpycon

Fluent14Brendan Eich

The document discusses advancements in JavaScript, particularly focusing on ECMAScript 6 (ES6) and ECMAScript 7 (ES7), highlighting new features such as classes, modules, and operator overloading. It contrasts the 'high road' enhancements for developers with 'low road' performance improvements through native types and SIMD capabilities. The conclusion emphasizes the resilience and innovation of web developers in transforming JavaScript and web applications.

Just KotlinIsmail Habib Muhammad

The document introduces Kotlin, an open source programming language that compiles to JVM bytecode and JavaScript. It highlights some of Kotlin's features like type inference, data classes, extension functions, null safety, functional programming constructs like lambdas and algebraic data types, and support for immutability. The document provides code examples to illustrate Kotlin's concise syntax for these features and how they allow for more expressive and safer code compared to Java.

Introduction to clojureAbhishek Mahawar

Clojure is a Lisp dialect created by Rich Hickey in 2008 that runs on the Java Virtual Machine. It is a dynamic, functional programming language with immutable persistent data structures and supports proper equality semantics. Clojure code is made up of data structures and uses homoiconicity, where code is represented as standard data structures. It has many standard data types like integers, doubles, ratios, strings, symbols and keywords, as well as collection data structures like lists, vectors, and maps.

Simple Jackson with DropWizardTatu Saloranta

The presentation by Tatu Saloranta covers the use of Jackson with Dropwizard for JSON data-binding, elaborating on how to read JSON into Java objects and vice versa. It highlights the ease of use of Jackson, the ability to customize using annotations, and various data type modules available for enhanced functionality. The talk also touches on the flexibility of using a tree model for handling JSON and the potential for dynamic and complex JSON structures.

Jackson beyond JSON: XML, CSVTatu Saloranta

The document discusses extending Jackson's functionality through various data format modules for processing XML, CSV, and more, enabling features like streaming APIs and data-binding capabilities. It outlines usage scenarios for Dropwizard, including JAX-RS provider configurations, DIY approaches, and specific XML and CSV handling with custom annotations and schemas. Key takeaways include the versatility of Jackson for different formats and suggestions for future enhancements such as dynamic binary JSON support.

Writing Groovy DSLsadam1davis

This document summarizes Adam L. Davis' presentation on writing Groovy domain-specific languages (DSLs). It discusses key Groovy features for building DSLs like command chains, named parameters, operator overloading, categories/extension modules, closures, property/method missing, Groovy scripts, and common Groovy DSL examples including Gradle, JSONBuilder, and GrooCSS. The presentation provides code examples demonstrating how to implement DSL functionality in Groovy.

JavaScript Foundations Day1Troy Miles

This document provides an agenda and overview for a two-day JavaScript foundations training course taught by Troy Miles. Day one covers JavaScript fundamentals like variables, data types, operators, and functions. It also covers controlling program flow and object-oriented programming. Day two covers working with objects and JSON, functional programming, good coding practices, and an overview of ECMAScript 2015 features. The document provides tips for participants to follow along, do exercises, and ask questions. It also includes summaries of key JavaScript concepts to be covered each day like the global object, equality operators, and string and date object methods.

Programming with Freedom & JoyHildeberto Mendonça

The document discusses the author's transition from Java EE to Clojure, highlighting the limitations of Java EE and the benefits of Clojure, including its functional programming features and simplicity in handling data structures. It provides a brief overview of Clojure's syntax, data structures, and community, emphasizing the author's positive experiences with the language at various conferences. The author expresses a sense of liberation and joy in programming with Clojure compared to their previous experiences with Java.

Python bootcamp - C4Dlab, University of Nairobikrmboya

Structure and interpretation of computer programs modularity, objects, and ...bdemchak

This document discusses object-oriented programming concepts in functional languages like Clojure. It presents an example of creating a simple "min object" in Clojure that encapsulates state using atoms. The document explains how Clojure implements objects using environments and binding of functions, allowing state to be retained despite immutability. It compares data encapsulation and scoping between Clojure, Java, and Pascal.

C# Starter L03-UtilitiesMohammad Shaker

This document contains a summary of topics covered in a C# programming course, including const and readonly keywords, casting, the is keyword, enums, exception handling, unsafe code, nullable types, the using keyword, and files. The agenda covers direct casting vs casting with the "as" keyword, checking types with "is", defining enums, trying/catching exceptions, creating custom exceptions, using unsafe code, declaring nullable types, using directives vs statements, and opening/closing files.

Hackersnlchriseidhof

Hw09 Hadoop + ClojureCloudera, Inc.

Clojure classAysylu Greenberg

The document provides an agenda for a two-day workshop on Clojure. Day one covers Clojure overviews and fundamentals including syntax, functions, flow control, and collections. Day two covers additional topics like testing, concurrency, polymorphism, performance, and tooling. The document also provides background on Clojure being a Lisp designed for functional programming and concurrency on the JVM.

Kotlin for Android DevelopmentSpeck&Tech

The document discusses Kotlin, a programming language developed by JetBrains that targets JVM, Android, and JavaScript, emphasizing its interoperability with Java and advantages over Java 6 limitations for Android development. It highlights Kotlin's features such as immutability, nullability handling, extension functions, and the Anko library for simplifying UI layout generation and asynchronous tasks. The document also provides coding examples illustrating how Kotlin reduces boilerplate code and enhances functionality.

More Related Content

What's hot (20)

Tour de Jackson: Forgotten Features of Jackson JSON processorTatu Saloranta

The Ring programming language version 1.8 book - Part 7 of 202Mahmoud Samir Fayed

Pune Clojure Course OutlineBaishampayan Ghose

Learning groovy -EU workshopadam1davis

Head First Java Chapter 1Tom Henricksen

Introduction to Groovy (Serbian Developer Conference 2013)Joachim Baumann

Python internals and how they affect your code - kasra ahmadvandirpycon

Fluent14Brendan Eich

Just KotlinIsmail Habib Muhammad

Introduction to clojureAbhishek Mahawar

Simple Jackson with DropWizardTatu Saloranta

Jackson beyond JSON: XML, CSVTatu Saloranta

Writing Groovy DSLsadam1davis

JavaScript Foundations Day1Troy Miles

Programming with Freedom & JoyHildeberto Mendonça

Python bootcamp - C4Dlab, University of Nairobikrmboya

Structure and interpretation of computer programs modularity, objects, and ...bdemchak

C# Starter L03-UtilitiesMohammad Shaker

Hackersnlchriseidhof

Hw09 Hadoop + ClojureCloudera, Inc.

Tour de Jackson: Forgotten Features of Jackson JSON processorTatu Saloranta

The Ring programming language version 1.8 book - Part 7 of 202Mahmoud Samir Fayed

Pune Clojure Course OutlineBaishampayan Ghose

Learning groovy -EU workshopadam1davis

Head First Java Chapter 1Tom Henricksen

Introduction to Groovy (Serbian Developer Conference 2013)Joachim Baumann

Python internals and how they affect your code - kasra ahmadvandirpycon

Fluent14Brendan Eich

Just KotlinIsmail Habib Muhammad

Introduction to clojureAbhishek Mahawar

Simple Jackson with DropWizardTatu Saloranta

Jackson beyond JSON: XML, CSVTatu Saloranta

Writing Groovy DSLsadam1davis

JavaScript Foundations Day1Troy Miles

Programming with Freedom & JoyHildeberto Mendonça

Python bootcamp - C4Dlab, University of Nairobikrmboya

Structure and interpretation of computer programs modularity, objects, and ...bdemchak

C# Starter L03-UtilitiesMohammad Shaker

Hackersnlchriseidhof

Hw09 Hadoop + ClojureCloudera, Inc.

Similar to Clojure Small Intro (20)

Clojure classAysylu Greenberg

Kotlin for Android DevelopmentSpeck&Tech

What can be done with Java, but should better be done with Erlang (@pavlobaron)Pavlo Baron

Erlang excels at building distributed, fault-tolerant, concurrent applications due to its lightweight process model and built-in support for distribution. However, Java is more full-featured and is generally a better choice for applications that require more traditional object-oriented capabilities or need to interface with existing Java libraries and frameworks. Both languages have their appropriate uses depending on the requirements of the specific application being developed.

Introduction to clojureAbbas Raza

This document provides a summary of an introduction to the Clojure programming language. It discusses what Clojure is, its timeline and adoption, functional programming concepts, concurrency features using Software Transactional Memory, the Lisp ideology it is based on including homoiconicity and its macro system. It also provides an overview of getting started with Clojure including using the REPL, basic syntax like symbols and keywords, data types, sequences, functions, and Java interoperability. Resources for learning more about Clojure are also listed.

Poniendo Kotlin en producción a palos (Kotlin in production, the hard way)Andrés Viedma Peláez

The document discusses the implementation and advantages of Kotlin, focusing on features such as null safety, immutability, and functional programming aspects. It compares Kotlin with Java, highlighting both the learning curve and the integration challenges in a corporate environment while emphasizing Kotlin's continued adoption across multiple teams. Ultimately, it presents a balanced view on whether adopting Kotlin is beneficial, weighing its syntactic advantages against potential risks and performance concerns.

Clojure made-simple - John StevensonJAX London

This document provides an overview of Clojure and why one may want to try it. Some key points include: - Clojure is a functional programming language that runs on the JVM and allows easy interoperability with Java. - It has a very small and elegant syntax based on Lisp with sensible macro names and prefix notation. - Clojure encourages pure functional programming and the use of immutable data structures, while providing tools like Software Transactional Memory to allow safe mutable state changes. - Its focus on functions as first-class citizens and referential transparency can provide benefits for writing parallel and concurrent code more easily compared to other languages.

Clojure for Java developers - StockholmJan Kronquist

This document provides an overview of the Clojure programming language from the perspective of a Java developer. It begins with an introduction to the presenter and an outline of what will not be covered. It then discusses some popular Clojure applications and frameworks. The core sections explain that Clojure was created in 2007, is a Lisp dialect that runs on the JVM and JavaScript, and is designed for concurrency. It provides an example of Clojure code, discusses reasons for using Clojure like its functional nature and interactive development environment. It addresses common complaints about Clojure and discusses Lisp concepts. It also covers Clojure data types, programming structures, working with Java classes using macros, editor support

A Brief Introduction to Scala for Java DevelopersMiles Sabin

Miles Sabin Introduction To Scala For Java DevelopersSkills Matter

Ceylon - the language and its toolsMax Andersen

BCS SPA 2010 - An Introduction to Scala for Java DevelopersMiles Sabin

This document provides an introduction to Scala for Java developers. It outlines how Scala cleans up Java syntax by making semi-colons optional, using == for equals and eq for reference equality, and allowing periods to be omitted. It also describes how Scala goes beyond Java by supporting features like case classes, pattern matching, named and default arguments, and mixin composition with traits. The document provides examples of using these features and explains how Scala seamlessly interoperates with Java.

An Introduction to Scala for Java DevelopersMiles Sabin

Music as dataJohn Vlachoyiannis

This document introduces John Vlachoyiannis and discusses live programming of music using Clojure. It outlines how Clojure allows music to be treated as data that can be manipulated and transformed in real time. Examples are given showing how to define notes and samples as data, generate patterns, and manipulate those patterns by reversing, randomizing, or applying other transformations to the music structure. Live programming is enabled through use of the REPL and functions like play! that allow musical experiments to be conducted and heard immediately.

Scalasuraj_atreya

Scala is a programming language that runs on the Java Virtual Machine (JVM) and is designed to express common programming patterns in a concise, elegant, and type-safe way. Some key points about Scala include that it is functional and object-oriented, statically typed, and allows seamless integration with Java. Scala code is often more concise than equivalent Java code through features like pattern matching and immutable data structures. Functional programming principles like pure functions, recursion, and avoiding side effects are emphasized in Scala.

Clojure And SwingSkills Matter

Clojure and Swing – a new productivity sweet spot? discusses how Clojure, a Lisp dialect that runs on the JVM, can be used to develop graphical user interfaces (GUIs) using Java Swing in a more productive way than plain Java. It presents several advantages of Clojure for Swing development, such as reducing boilerplate code, easier definition of actions and event bindings, and increased flexibility and reusability through functional programming techniques. Examples are provided of common Swing programming tasks implemented more concisely and readably in Clojure compared to Java. The document concludes that Clojure is a powerful and flexible language that offers opportunities to apply Lisp concepts to Swing GUI development

Getting started with ClojureJohn Stevenson

This document provides an introduction to Clojure, a functional programming language that runs on the JVM, emphasizing its unique features such as immutable state, rich interoperability with Java, and a focus on pure functions. It discusses the advantages of using Clojure, including ease of understanding and cleaner concurrency management, while also mentioning potential downsides like tool support issues. The document includes practical examples of Clojure syntax, data structures, and libraries, along with resources for further learning.

Beyond java8Muhammad Durrah

The document outlines the evolution of Java beyond version 8, highlighting key features introduced in recent versions such as Java 9 to 14, including modular systems, private interface methods, local-variable type inference, switch expressions, and records. It discusses improvements and changes made to the Java development process, including enhanced encapsulation and collection factory methods. The document also touches on various experimental features and enhancements in Java, including the removal of outdated modules and the introduction of new APIs.

Clojurealandipert

Clojure is a functional programming language that runs on the JVM and CLR, emphasizing immutability and concurrency with a lisp syntax. It supports interoperability with Java and C#, allowing easy interaction with external libraries and objects, all while maintaining a dynamic and flexible code structure. Key features include higher-order functions, persistent data structures, and a focus on minimizing mutable state to enhance concurrency and reduce bugs.

Introduction to Scala for JCConf TaiwanJimin Hsieh

The document is an introduction to Scala, highlighting its programming concepts, advantages over Java, and its object-oriented and functional programming features. It covers various aspects of Scala, including expressions, classes, types, and pattern matching, along with practical programming examples. Additionally, it discusses the use of functions, recursion, and the differences between Scala constructs like traits and abstract classes.

Kotlin - The Swiss army knife of programming languages - Visma Mobile Meet-up...Tudor Dragan

The document is a presentation by Tudor Dragan on Kotlin, a statically typed programming language that operates on the Java Virtual Machine and offers features like null safety and data classes. It compares Kotlin with Java and Swift, discussing functional programming, delegation patterns, and upcoming Kotlin/Native capabilities for compiling to native binaries. The talk also covers aspects of developer happiness and future trends in Kotlin development.

Clojure classAysylu Greenberg

Kotlin for Android DevelopmentSpeck&Tech

What can be done with Java, but should better be done with Erlang (@pavlobaron)Pavlo Baron

Introduction to clojureAbbas Raza

Poniendo Kotlin en producción a palos (Kotlin in production, the hard way)Andrés Viedma Peláez

Clojure made-simple - John StevensonJAX London

Clojure for Java developers - StockholmJan Kronquist

A Brief Introduction to Scala for Java DevelopersMiles Sabin

Miles Sabin Introduction To Scala For Java DevelopersSkills Matter

Ceylon - the language and its toolsMax Andersen

BCS SPA 2010 - An Introduction to Scala for Java DevelopersMiles Sabin

An Introduction to Scala for Java DevelopersMiles Sabin

Music as dataJohn Vlachoyiannis

Scalasuraj_atreya

Clojure And SwingSkills Matter

Getting started with ClojureJohn Stevenson

Beyond java8Muhammad Durrah

Clojurealandipert

Introduction to Scala for JCConf TaiwanJimin Hsieh

Kotlin - The Swiss army knife of programming languages - Visma Mobile Meet-up...Tudor Dragan

More from John Vlachoyiannis (6)

Making gazillion with cryptocurrenciesJohn Vlachoyiannis

This document discusses cryptocurrency trading and algorithmic trading. It describes the author's experience developing algorithms for trading on the Ethereum blockchain. It outlines a simple arbitrage algorithm the author used in 2016 that took advantage of price differences between exchanges to generate profits, though these were ultimately lost in The DAO hack. The author has since founded a quantitative wealth management firm and continues developing trading strategies and tools.

The most epic advice to become an angel investorJohn Vlachoyiannis

This document discusses common traits of successful startups and provides examples of real startups from the author's portfolio to analyze their successes and failures. It notes that the most important factor for a startup's success is the quality of its founding team. The examples show that startups can succeed despite obstacles if they have a great product, low costs, and a team that is highly focused and takes feedback well. Conversely, startups can fail quickly due to an unfocused team, bad management, lack of product-market fit, or defensive founders who don't accept feedback.

Music as Data - Ignite 2011 SFJohn Vlachoyiannis

This document discusses the connections between code, data, and music. It provides examples of representing musical patterns and compositions as code by mapping notes to data structures. The document suggests sharing and collaborating on music by representing it as code that can be version controlled and transformed through data operations. Examples are given of generating music from Twitter data and ClojureScript libraries for interactive music programming.

This is Appengine! 300 reasons to love Google AppEngineJohn Vlachoyiannis

This document lists 300 reasons to use Google AppEngine, including that it provides static file hosting, dynamic request handling, data storage, access to external APIs and Google's user authentication. AppEngine also includes services like Memcache, email sending/receiving, image processing, and automatic scaling. While not computational intensive, it is suitable for mobile backends, Facebook apps, CRMs, dynamic and static sites. The key advantages are free hosting with scaling to infinity, although some limitations exist from its Spartan infrastructure.

Rain up presentation (erlang factory)John Vlachoyiannis

This document provides an overview of RainUp, a light-weight distributed computing and advertising platform. It discusses RainUp's central server and node architecture, innovative web service features like problem voting, and plans for corporate social responsibility initiatives. The document outlines RainUp's phased approach, beginning with securing funding, hardware, and developing initial algorithms, then solving an initial voted-on problem and testing RainDrops before ultimately aiming to scale the network to infinity through an global alliance.

Metaprogramming in RubyJohn Vlachoyiannis

This document discusses metaprogramming in Ruby. It begins by mentioning Lisp and how Ruby can think like Lisp through metaprogramming. It then discusses creating languages from scratch or using tools like Bison/yacc/lex. It recommends learning from languages like Lisp, Scheme, Forth and Smalltalk that pioneered metaprogramming techniques. The document discusses how metaprogramming allows code to be treated as data through techniques like self-modifying code and dynamic adding/removing of classes and functions. It provides examples of metaprogramming in areas like web frameworks and AI. It discusses tools for metaprogramming in Ruby like operator overriding, open classes, method_missing, blocks and eval. Finally, it demonstrates

Making gazillion with cryptocurrenciesJohn Vlachoyiannis

The most epic advice to become an angel investorJohn Vlachoyiannis

Music as Data - Ignite 2011 SFJohn Vlachoyiannis

This is Appengine! 300 reasons to love Google AppEngineJohn Vlachoyiannis

Rain up presentation (erlang factory)John Vlachoyiannis

Metaprogramming in RubyJohn Vlachoyiannis

Recently uploaded (20)

Floods in Valencia: Two FME-Powered Stories of Data ResilienceSafe Software

In October 2024, the Spanish region of Valencia faced severe flooding that underscored the critical need for accessible and actionable data. This presentation will explore two innovative use cases where FME facilitated data integration and availability during the crisis. The first case demonstrates how FME was used to process and convert satellite imagery and other geospatial data into formats tailored for rapid analysis by emergency teams. The second case delves into making human mobility data—collected from mobile phone signals—accessible as source-destination matrices, offering key insights into population movements during and after the flooding. These stories highlight how FME's powerful capabilities can bridge the gap between raw data and decision-making, fostering resilience and preparedness in the face of natural disasters. Attendees will gain practical insights into how FME can support crisis management and urban planning in a changing climate.

“From Enterprise to Makers: Driving Vision AI Innovation at the Extreme Edge,...Edge AI and Vision Alliance

For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2025/06/from-enterprise-to-makers-driving-vision-ai-innovation-at-the-extreme-edge-a-presentation-from-sony-semiconductor-solutions/ Amir Servi, Edge Deep Learning Product Manager at Sony Semiconductor Solutions, presents the “From Enterprise to Makers: Driving Vision AI Innovation at the Extreme Edge” tutorial at the May 2025 Embedded Vision Summit. Sony’s unique integrated sensor-processor technology is enabling ultra-efficient intelligence directly at the image source, transforming vision AI for enterprises and developers alike. In this presentation, Servi showcases how the AITRIOS platform simplifies vision AI for enterprises with tools for large-scale deployments and model management. Servi also highlights his company’s collaboration with Ultralytics and Raspberry Pi, which brings YOLO models to the developer community, empowering grassroots innovation. Whether you’re scaling vision AI for industry or experimenting with cutting-edge tools, this presentation will demonstrate how Sony is accelerating high-performance, energy-efficient vision AI for all.

Murdledescargadarkweb.pdfvolumen1 100 elementaryJorgeSemperteguiMont

FIDO Seminar: Perspectives on Passkeys & Consumer Adoption.pptxFIDO Alliance

“Why It’s Critical to Have an Integrated Development Methodology for Edge AI,...Edge AI and Vision Alliance

For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2025/06/why-its-critical-to-have-an-integrated-development-methodology-for-edge-ai-a-presentation-from-lattice-semiconductor/ Sreepada Hegade, Director of ML Systems and Software at Lattice Semiconductor, presents the “Why It’s Critical to Have an Integrated Development Methodology for Edge AI” tutorial at the May 2025 Embedded Vision Summit. The deployment of neural networks near sensors brings well-known advantages such as lower latency, privacy and reduced overall system cost—but also brings significant challenges that complicate development. These challenges can be addressed effectively by choosing the right solution and design methodology. The low-power FPGAs from Lattice are well poised to enable efficient edge implementation of models, while Lattice’s proven development methodology helps to mitigate the challenges and risks associated with edge model deployment. In this presentation, Hegade explains the importance of an integrated framework that tightly consolidates different aspects of edge AI development, including training, quantization of networks for edge deployment, integration with sensors and inferencing. He also illustrates how Lattice’s simplified tool flow helps to achieve the best trade-off between power, performance and efficiency using low-power FPGAs for edge deployment of various AI workloads.

High Availability On-Premises FME Flow.pdfSafe Software

FME Flow is a highly robust tool for transforming data both automatically and by user-initiated workflows. At the Finnish telecommunications company Elisa, FME Flow serves processes and internal stakeholders that require 24/7 availability from underlying systems, while imposing limitations on the use of cloud based systems. In response to these business requirements, Elisa has implemented a high-availability on-premises setup of FME Flow, where all components of the system have been duplicated or clustered. The goal of the presentation is to provide insights into the architecture behind the high-availability functionality. The presentation will show in basic technical terms how the different parts of the system work together. Basic level understanding of IT technologies is required to understand the technical portion of the presentation, namely understanding the purpose of the following components: load balancer, FME Flow host nodes, FME Flow worker nodes, network file storage drives, databases, and external authentication services. The presentation will also outline our lessons learned from the high-availability project, both benefits and challenges to consider.

FME for Good: Integrating Multiple Data Sources with APIs to Support Local Ch...Safe Software

Have-a-skate-with-Bob (HASB-KC) is a local charity that holds two Hockey Tournaments every year to raise money in the fight against Pancreatic Cancer. The FME Form software is used to integrate and exchange data via API, between Google Forms, Google Sheets, Stripe payments, SmartWaiver, and the GoDaddy email marketing tools to build a grass-roots Customer Relationship Management (CRM) system for the charity. The CRM is used to communicate effectively and readily with the participants of the hockey events and most importantly the local area sponsors of the event. Communication consists of a BLOG used to inform participants of event details including, the ever-important team rosters. Funds raised by these events are used to support families in the local area to fight cancer and support PanCan research efforts to find a cure against this insidious disease. FME Form removes the tedium and error-prone manual ETL processes against these systems into 1 or 2 workbenches that put the data needed at the fingertips of the event organizers daily freeing them to work on outreach and marketing of the events in the community.

Mastering AI Workflows with FME - Peak of Data & AI 2025Safe Software

Harness the full potential of AI with FME: From creating high-quality training data to optimizing models and utilizing results, FME supports every step of your AI workflow. Seamlessly integrate a wide range of models, including those for data enhancement, forecasting, image and object recognition, and large language models. Customize AI models to meet your exact needs with FME’s powerful tools for training, optimization, and seamless integration

SAP Modernization Strategies for a Successful S/4HANA Journey.pdfPrecisely

FIDO Seminar: Targeting Trust: The Future of Identity in the Workforce.pptxFIDO Alliance

OpenACC and Open Hackathons Monthly Highlights June 2025OpenACC

The OpenACC organization focuses on enhancing parallel computing skills and advancing interoperability in scientific applications through hackathons and training. The upcoming 2025 Open Accelerated Computing Summit (OACS) aims to explore the convergence of AI and HPC in scientific computing and foster knowledge sharing. This year's OACS welcomes talk submissions from a variety of topics, from Using Standard Language Parallelism to Computer Vision Applications. The document also highlights several open hackathons, a call to apply for NVIDIA Academic Grant Program and resources for optimizing scientific applications using OpenACC directives.

“Key Requirements to Successfully Implement Generative AI in Edge Devices—Opt...Edge AI and Vision Alliance

For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2025/06/key-requirements-to-successfully-implement-generative-ai-in-edge-devices-optimized-mapping-to-the-enhanced-npx6-neural-processing-unit-ip-a-presentation-from-synopsys/ Gordon Cooper, Principal Product Manager at Synopsys, presents the “Key Requirements to Successfully Implement Generative AI in Edge Devices—Optimized Mapping to the Enhanced NPX6 Neural Processing Unit IP” tutorial at the May 2025 Embedded Vision Summit. In this talk, Cooper discusses emerging trends in generative AI for edge devices and the key role of transformer-based neural networks. He reviews the distinct attributes of transformers, their advantages over conventional convolutional neural networks and how they enable generative AI. Cooper then covers key requirements that must be met for neural processing units (NPU) to support transformers and generative AI in edge device applications. He uses transformer-based generative AI examples to illustrate the efficient mapping of these workloads onto the enhanced Synopsys ARC NPX NPU IP family.

The State of Web3 Industry- Industry ReportLiveplex

Web3 is poised for mainstream integration by 2030, with decentralized applications potentially reaching billions of users through improved scalability, user-friendly wallets, and regulatory clarity. Many forecasts project trillions of dollars in tokenized assets by 2030 , integration of AI, IoT, and Web3 (e.g. autonomous agents and decentralized physical infrastructure), and the possible emergence of global interoperability standards. Key challenges going forward include ensuring security at scale, preserving decentralization principles under regulatory oversight, and demonstrating tangible consumer value to sustain adoption beyond speculative cycles.

June Patch TuesdayIvanti

Ivanti’s Patch Tuesday breakdown goes beyond patching your applications and brings you the intelligence and guidance needed to prioritize where to focus your attention first. Catch early analysis on our Ivanti blog, then join industry expert Chris Goettl for the Patch Tuesday Webinar Event. There we’ll do a deep dive into each of the bulletins and give guidance on the risks associated with the newly-identified vulnerabilities.

AI VIDEO MAGAZINE - June 2025 - r/aivideo1pcity Studios, Inc

Edge-banding-machines-edgeteq-s-200-en-.pdfAmirStern2

AudGram Review: Build Visually Appealing, AI-Enhanced Audiograms to Engage Yo...SOFTTECHHUB

OWASP Barcelona 2025 Threat Model LibraryPetraVukmirovic

Can We Use Rust to Develop Extensions for PostgreSQL? (POSETTE: An Event for ...NTT DATA Technology & Innovation

Integration of Utility Data into 3D BIM Models Using a 3D Solids Modeling Wor...Safe Software

Jacobs has developed a 3D utility solids modelling workflow to improve the integration of utility data into 3D Building Information Modeling (BIM) environments. This workflow, a collaborative effort between the New Zealand Geospatial Team and the Australian Data Capture Team, employs FME to convert 2D utility data into detailed 3D representations, supporting enhanced spatial analysis and clash detection. To enable the automation of this process, Jacobs has also developed a survey data standard that standardizes the capture of existing utilities. This standard ensures consistency in data collection, forming the foundation for the subsequent automated validation and modelling steps. The workflow begins with the acquisition of utility survey data, including attributes such as location, depth, diameter, and material of utility assets like pipes and manholes. This data is validated through a custom-built tool that ensures completeness and logical consistency, including checks for proper connectivity between network components. Following validation, the data is processed using an automated modelling tool to generate 3D solids from 2D geometric representations. These solids are then integrated into BIM models to facilitate compatibility with 3D workflows and enable detailed spatial analyses. The workflow contributes to improved spatial understanding by visualizing the relationships between utilities and other infrastructure elements. The automation of validation and modeling processes ensures consistent and accurate outputs, minimizing errors and increasing workflow efficiency. This methodology highlights the application of FME in addressing challenges associated with geospatial data transformation and demonstrates its utility in enhancing data integration within BIM frameworks. By enabling accurate 3D representation of utility networks, the workflow supports improved design collaboration and decision-making in complex infrastructure projects

Floods in Valencia: Two FME-Powered Stories of Data ResilienceSafe Software

“From Enterprise to Makers: Driving Vision AI Innovation at the Extreme Edge,...Edge AI and Vision Alliance

Murdledescargadarkweb.pdfvolumen1 100 elementaryJorgeSemperteguiMont

FIDO Seminar: Perspectives on Passkeys & Consumer Adoption.pptxFIDO Alliance

“Why It’s Critical to Have an Integrated Development Methodology for Edge AI,...Edge AI and Vision Alliance

High Availability On-Premises FME Flow.pdfSafe Software

FME for Good: Integrating Multiple Data Sources with APIs to Support Local Ch...Safe Software

Mastering AI Workflows with FME - Peak of Data & AI 2025Safe Software

SAP Modernization Strategies for a Successful S/4HANA Journey.pdfPrecisely

FIDO Seminar: Targeting Trust: The Future of Identity in the Workforce.pptxFIDO Alliance

OpenACC and Open Hackathons Monthly Highlights June 2025OpenACC

“Key Requirements to Successfully Implement Generative AI in Edge Devices—Opt...Edge AI and Vision Alliance

The State of Web3 Industry- Industry ReportLiveplex

June Patch TuesdayIvanti

AI VIDEO MAGAZINE - June 2025 - r/aivideo1pcity Studios, Inc

Edge-banding-machines-edgeteq-s-200-en-.pdfAmirStern2

AudGram Review: Build Visually Appealing, AI-Enhanced Audiograms to Engage Yo...SOFTTECHHUB

OWASP Barcelona 2025 Threat Model LibraryPetraVukmirovic

Can We Use Rust to Develop Extensions for PostgreSQL? (POSETTE: An Event for ...NTT DATA Technology & Innovation

Integration of Utility Data into 3D BIM Models Using a 3D Solids Modeling Wor...Safe Software

Clojure Small Intro

1. Clojure John Vlachoyiannis @jonromero [email protected] Http://jon.is.emotionull.com

2. What is Clojure?

3. Ok, what is Lisp?

4. “Lisp is worth learning for the profound enlightenment experience you will have when you finally get it; that experience will make you a better programmer for the rest of your days, even if you never actually use Lisp itself a lot." Eric S. Raymond, "How to Become a Hacker".

5. “LISP stands for: Lots of Insane Stupid Parentheses” Anonymous

6. The Truth about Lisp

7. LISt Processing LIS ● Second oldest high-level language (first is Fortran) ● Code as Data (Homoiconic) ● Perfect for Domain-specific languages (DSL) ● Exploratory programming

8. Clojure ● Lisp in JVM ● Concurrent programming ● Dynamic Development (REPL) ● Lazy sequences ● No side effects (almost)

9. Enter Clojure

10. Everything is code

11. (println "Hello World") function argument

12. Everything is data

13. (println "Hello World") list symbol string

14. ● Integers – 1234567891234 ● Doubles – 3.14. BigDecimals – 3.14M ● Ratios – 22/4 ● Strings – '”foo”, Character – a b c ● Symbols – foo, Keywords :foo ● Booleans – true false, Null – nil ● Regex patterns – #”[a-zA-Z0-9]|

15. Data structures ● Lists (1 2 3 4), (foo bar baz), (list 1 2 3) ● ● Vectors [1 2 3], [foo bar], (vector 1 2 3) ● ● Maps {:a 1 :b 2 :c 3} ● ● Sets ● #{foo bar}

16. “It is better to have 100 functions operate on one data structure than to have 10 functions operate on 10 data Structures.” Alan J. Perlis

17. clojure might be a better java than java

18. public class StringUtils { public static boolean isBlank(String str) { int strLen; if (str == null || (strLen = str.length()) == 0) { return true; } for (int i = 0; i < strLen; i++) { if ((Character.isWhitespace(str.charAt(i)) == false)) { return false; } } return true; } }

19. public class StringUtils { public isBlank(str) { if (str == null || (strLen = str.length()) == 0) { return true; } for (i = 0; i < strLen; i++) { if ((Character.isWhitespace(str.charAt(i)) == false)) { return false; } } return true; } }

20. public isBlank(str) { if (str == null || (strLen = str.length()) == 0) { return true; } for (i = 0; i < strLen; i++) { if ((Character.isWhitespace(str.charAt(i)) == false)) return false; } } return true; }

21. public isBlank(str) { if (str == null || (strLen = str.length()) == 0) { return true; } every (ch in str) { Character.isWhitespace(ch); } return true; }

22. public isBlank(str) { every (ch in str) { Character.isWhitespace(ch); } }

23. (defn blank? [s] (every? #(Character/isWhitespace %) s))

24. Clojure vs Java code ● Side-effect free ● Error prone ● Easy to (unit) test ● Not so easy ● Lazy collection ● Only one element ● Any element ● Only with chars ● Slower ● Faster ● Data manipulation ● If/for/while code ● Exploratory ● Design Is Law

25. Clojure is a functional language ● Functions are first-class objects ● Data is immutable ● Functions are pure

26. So what?

27. ● Simple: no loops, variables or mutable state ● Thread-safe: no locking ● Parallelizable: map/reduce anyone? ● Generic: data is always data ● Easy to test: same input, same output

28. user=> (println "hello world") | hello world -> nil

29. user=> (defn hello [name] (str "Hello, " name)) #'user/hello

30. (hello "Clojure")

31. (.toUpperCase “hello”)

32. (str “hello” “ “ “world”)

33. (+ 1 3 4 (* 5 6))

34. (defn greeting "Returns a greeting of the form 'Hello, username.'" [username] (str "Hello, " username))

35. (greeting "world")

36. user=> (doc greeting) ------------------------- exploring/greeting ([username]) Returns a greeting of the form 'Hello, username.'

37. (defn is-small? [number] (if (< number 100) "yes" ))

38. (is-small? 50) "yes"

39. (is-small? 50000) nil

40. (defn is-small? [number] (if (< number 100) "yes" "no" ))

41. Solving problems ● Experiment with the problem ● Create your data structures ● Data transformations ● Write code that writes code for you (macros) ● Create a mini language (a DSL)

42. Java in Clojure ● Yeap

43. Clojure in Java ● Yeap

44. Clojure in Clojure ● Yeap, yeap

45. Java in Clojure java new Widget(“foo”) clojure (Widget. “foo”) java dialog.show() clojure (.show dialog)

46. Tools ● Emacs + SLIME ● ViMClojure ● Enclojure + Intellij IDEA ● Counterclockwise + Eclipse ● Leiningen

47. Clojure is not a just a new language

48. Is another, simplier way to solve problems

49. Thanks! Questions? @jonromero

Clojure Small Intro

Recommended

More Related Content

What's hot (20)

Similar to Clojure Small Intro (20)

More from John Vlachoyiannis (6)

Recently uploaded (20)

Clojure Small Intro