This document provides an introduction to the Clojure programming language. Clojure is a dynamic, functional programming language for the Java Virtual Machine (JVM). The document discusses Clojure's fundamentals including being dynamic, functional, hosted on the JVM, and supporting concurrency. It also covers Clojure's syntax, data types, Java integration, functional programming features, and concurrency model using immutable persistent data structures and software transactional memory.
www.denizoguz.com-For an in company JDK 7 orientation I have prepared a presentation which summaries new features of JDK 7. I would like to make it public for everyone who needs it.
Finally Java SE 7 is GA and you can start using it. This talk will cover the most important new features of the language and the virtual machine. It will also cover some features that did not make it in to the SE 7 release. Finally we will discuss current state of Java as an ecosystem and my analysis and hopes for the future.
www.denizoguz.com-For an in company JDK 7 orientation I have prepared a presentation which summaries new features of JDK 7. I would like to make it public for everyone who needs it.
Finally Java SE 7 is GA and you can start using it. This talk will cover the most important new features of the language and the virtual machine. It will also cover some features that did not make it in to the SE 7 release. Finally we will discuss current state of Java as an ecosystem and my analysis and hopes for the future.
Presented at BJUG, 6/12/2012 by Roger Brinkley
This talk is on 55 new features in Java 7 you (probably) didn't hear about in an ignite format of one per minute. No stopping, no going back....Questions, sure but only if time remains (otherwise save for later).
The big language features for Java SE 8 are lambda expressions (a.k.a. closures) and default methods (a.k.a. virtual extension methods). Adding closures to the Java language opens up a host of new expressive opportunities for applications and libraries, but how are they implemented? You might assume that lambda expressions are simply a compact syntax for inner classes, but, in fact, the implementation of lambda expressions is substantially different and builds on the invokedynamic feature added in Java SE 7.
Model Manipulation Using Embedded DSLs in ScalaFilip Krikava
A short presentation (student talk category) given at the Scala Workshop 2013 in Montpellier, France (2.7.2013). This is slightly extended version to be more self-contained. It presents the basics of Sigma such as the common infrastructure support, model consistency checking and model transformation together with some perspectives of further deep embedding.
A presentation at Twitter's official developer conference, Chirp, about why we use the Scala programming language and how we build services in it. Provides a tour of a number of libraries and tools, both developed at Twitter and otherwise.
Mixing Source and Bytecode: A Case for Compilation By Normalization (OOPSLA 2...lennartkats
Language extensions increase programmer productivity by providing concise, often domain-specific syntax, and support for static verification of correctness, security, and style constraints. Language extensions can often be realized through translation to the base language, supported by preprocessors and extensible compilers. However, various kinds of extensions require further adaptation of a base compiler's internal stages and components, for example to support separate compilation or to make use of low-level primitives of the platform (e.g., jump instructions or unbalanced synchronization). To allow for a more loosely coupled approach, we propose an open compiler model based on normalization steps from a high-level language to a subset of it, the core language. We developed such a compiler for a mixed Java and (core) bytecode language, and evaluate its effectiveness for composition mechanisms such as traits, as well as statement-level and expression-level language extensions.
Java is a general-purpose, object-oriented computer programming language that offers special features that allow programs to take advantage of the power and flexibility of the Internet.
Presented at BJUG, 6/12/2012 by Roger Brinkley
This talk is on 55 new features in Java 7 you (probably) didn't hear about in an ignite format of one per minute. No stopping, no going back....Questions, sure but only if time remains (otherwise save for later).
The big language features for Java SE 8 are lambda expressions (a.k.a. closures) and default methods (a.k.a. virtual extension methods). Adding closures to the Java language opens up a host of new expressive opportunities for applications and libraries, but how are they implemented? You might assume that lambda expressions are simply a compact syntax for inner classes, but, in fact, the implementation of lambda expressions is substantially different and builds on the invokedynamic feature added in Java SE 7.
Model Manipulation Using Embedded DSLs in ScalaFilip Krikava
A short presentation (student talk category) given at the Scala Workshop 2013 in Montpellier, France (2.7.2013). This is slightly extended version to be more self-contained. It presents the basics of Sigma such as the common infrastructure support, model consistency checking and model transformation together with some perspectives of further deep embedding.
A presentation at Twitter's official developer conference, Chirp, about why we use the Scala programming language and how we build services in it. Provides a tour of a number of libraries and tools, both developed at Twitter and otherwise.
Mixing Source and Bytecode: A Case for Compilation By Normalization (OOPSLA 2...lennartkats
Language extensions increase programmer productivity by providing concise, often domain-specific syntax, and support for static verification of correctness, security, and style constraints. Language extensions can often be realized through translation to the base language, supported by preprocessors and extensible compilers. However, various kinds of extensions require further adaptation of a base compiler's internal stages and components, for example to support separate compilation or to make use of low-level primitives of the platform (e.g., jump instructions or unbalanced synchronization). To allow for a more loosely coupled approach, we propose an open compiler model based on normalization steps from a high-level language to a subset of it, the core language. We developed such a compiler for a mixed Java and (core) bytecode language, and evaluate its effectiveness for composition mechanisms such as traits, as well as statement-level and expression-level language extensions.
Java is a general-purpose, object-oriented computer programming language that offers special features that allow programs to take advantage of the power and flexibility of the Internet.
Distributed Model Validation with EpsilonSina Madani
Scalable performance is a major challenge with current model management tools. As the size and complexity of models and model management programs increases and the cost of computing falls, one solution for improving performance of model management programs is to perform computations on multiple computers. The developed prototype demonstrates a low-overhead data-parallel approach for distributed model validation in the context of an OCL-like language. The approach minimises communication costs by exploiting the deterministic structure of programs and can take advantage of multiple cores on each (heterogenous) machine with highly configurable computational granularity. Performance evaluation shows linear improvements with more machines and processor cores, being up to 340x faster than the baseline sequential program with 88 computers.
Since 2.10.0 Scala includes macros. I was talk about something like the following:
* What do macros benefit to us?
* What can we do with macros?
* Actual use cases
CoFX is the framework behind time cockpit (http://www.timecockpit.com). Learn about the data model of CoFX and see how to use it to extend time cockpit.
Alt. GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using ...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
In his public lecture, Christian Timmerer provides insights into the fascinating history of video streaming, starting from its humble beginnings before YouTube to the groundbreaking technologies that now dominate platforms like Netflix and ORF ON. Timmerer also presents provocative contributions of his own that have significantly influenced the industry. He concludes by looking at future challenges and invites the audience to join in a discussion.
Generative AI Deep Dive: Advancing from Proof of Concept to ProductionAggregage
Join Maher Hanafi, VP of Engineering at Betterworks, in this new session where he'll share a practical framework to transform Gen AI prototypes into impactful products! He'll delve into the complexities of data collection and management, model selection and optimization, and ensuring security, scalability, and responsible use.
DevOps and Testing slides at DASA ConnectKari Kakkonen
My and Rik Marselis slides at 30.5.2024 DASA Connect conference. We discuss about what is testing, then what is agile testing and finally what is Testing in DevOps. Finally we had lovely workshop with the participants trying to find out different ways to think about quality and testing in different parts of the DevOps infinity loop.
Removing Uninteresting Bytes in Software FuzzingAftab Hussain
Imagine a world where software fuzzing, the process of mutating bytes in test seeds to uncover hidden and erroneous program behaviors, becomes faster and more effective. A lot depends on the initial seeds, which can significantly dictate the trajectory of a fuzzing campaign, particularly in terms of how long it takes to uncover interesting behaviour in your code. We introduce DIAR, a technique designed to speedup fuzzing campaigns by pinpointing and eliminating those uninteresting bytes in the seeds. Picture this: instead of wasting valuable resources on meaningless mutations in large, bloated seeds, DIAR removes the unnecessary bytes, streamlining the entire process.
In this work, we equipped AFL, a popular fuzzer, with DIAR and examined two critical Linux libraries -- Libxml's xmllint, a tool for parsing xml documents, and Binutil's readelf, an essential debugging and security analysis command-line tool used to display detailed information about ELF (Executable and Linkable Format). Our preliminary results show that AFL+DIAR does not only discover new paths more quickly but also achieves higher coverage overall. This work thus showcases how starting with lean and optimized seeds can lead to faster, more comprehensive fuzzing campaigns -- and DIAR helps you find such seeds.
- These are slides of the talk given at IEEE International Conference on Software Testing Verification and Validation Workshop, ICSTW 2022.
Elevating Tactical DDD Patterns Through Object CalisthenicsDorra BARTAGUIZ
After immersing yourself in the blue book and its red counterpart, attending DDD-focused conferences, and applying tactical patterns, you're left with a crucial question: How do I ensure my design is effective? Tactical patterns within Domain-Driven Design (DDD) serve as guiding principles for creating clear and manageable domain models. However, achieving success with these patterns requires additional guidance. Interestingly, we've observed that a set of constraints initially designed for training purposes remarkably aligns with effective pattern implementation, offering a more ‘mechanical’ approach. Let's explore together how Object Calisthenics can elevate the design of your tactical DDD patterns, offering concrete help for those venturing into DDD for the first time!
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
Encryption in Microsoft 365 - ExpertsLive Netherlands 2024Albert Hoitingh
In this session I delve into the encryption technology used in Microsoft 365 and Microsoft Purview. Including the concepts of Customer Key and Double Key Encryption.
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdfPaige Cruz
Monitoring and observability aren’t traditionally found in software curriculums and many of us cobble this knowledge together from whatever vendor or ecosystem we were first introduced to and whatever is a part of your current company’s observability stack.
While the dev and ops silo continues to crumble….many organizations still relegate monitoring & observability as the purview of ops, infra and SRE teams. This is a mistake - achieving a highly observable system requires collaboration up and down the stack.
I, a former op, would like to extend an invitation to all application developers to join the observability party will share these foundational concepts to build on:
A tale of scale & speed: How the US Navy is enabling software delivery from l...sonjaschweigert1
Rapid and secure feature delivery is a goal across every application team and every branch of the DoD. The Navy’s DevSecOps platform, Party Barge, has achieved:
- Reduction in onboarding time from 5 weeks to 1 day
- Improved developer experience and productivity through actionable findings and reduction of false positives
- Maintenance of superior security standards and inherent policy enforcement with Authorization to Operate (ATO)
Development teams can ship efficiently and ensure applications are cyber ready for Navy Authorizing Officials (AOs). In this webinar, Sigma Defense and Anchore will give attendees a look behind the scenes and demo secure pipeline automation and security artifacts that speed up application ATO and time to production.
We will cover:
- How to remove silos in DevSecOps
- How to build efficient development pipeline roles and component templates
- How to deliver security artifacts that matter for ATO’s (SBOMs, vulnerability reports, and policy evidence)
- How to streamline operations with automated policy checks on container images
Communications Mining Series - Zero to Hero - Session 1DianaGray10
This session provides introduction to UiPath Communication Mining, importance and platform overview. You will acquire a good understand of the phases in Communication Mining as we go over the platform with you. Topics covered:
• Communication Mining Overview
• Why is it important?
• How can it help today’s business and the benefits
• Phases in Communication Mining
• Demo on Platform overview
• Q/A
SAP Sapphire 2024 - ASUG301 building better apps with SAP Fiori.pdfPeter Spielvogel
Building better applications for business users with SAP Fiori.
• What is SAP Fiori and why it matters to you
• How a better user experience drives measurable business benefits
• How to get started with SAP Fiori today
• How SAP Fiori elements accelerates application development
• How SAP Build Code includes SAP Fiori tools and other generative artificial intelligence capabilities
• How SAP Fiori paves the way for using AI in SAP apps
GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using Deplo...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
4. Clojure Fundamentals
• Dynamic
• a new Lisp, not Common Lisp or Scheme
• Functional
• emphasis on immutability
• Hosted on the JVM
• Supporting Concurrency
• Open Source
5. Why use a dynamic
language?
• Flexibility
• Interactivity
• Concision
• Exploration
• Focus on your problem
6. Which dynamic language?
• Many options on the JVM
• allow you to leverage your existing
knowledge and code
• Ports to JVM
• JRuby
• Jython
• Native to JVM
• Groovy
• Clojure
7. Why Clojure?
• Expressive, elegant
• Good performance
• Useful for the same tasks Java is
• Wrapper-free Java access
• Powerful extensibility
• Functional programming and concurrency
8. Clojure is a Lisp
• Dynamic
• Code as data
• Reader
• Small core
• Sequences
• Syntactic abstraction
9. Dynamic development
• REPL - Read-eval-print-loop
• Define functions on the fly
• Load and compile code at runtime
• Introspection
• Interactive environment
10. Atomic Data Types
• Arbitrary precision integers -12345678987654
• Doubles , BigDecimals
1.234 1.234M
• Ratios -22/7
• Strings -“fred”, Characters -a b c
• Symbols - fred ethel , Keywords - :fred :ethel
• Booleans - true false , Null -
nil
• Regex patterns #“a*b”
12. Syntax
• You’ve just seen it
• Data structures are the code
• Homoiconicity
• No more text-based syntax
• Actually, syntax is in the interpretation of
data structures
15. Interactivity
Code
Text
characters
Effect
Reader
data structures
characters
evaluator/
bytecode JVM
compiler
You
16. Programs writing Programs
Code
Text
characters
Effect
Reader
data structures
characters
evaluator/
bytecode JVM
compiler
data structures
You
Program
17. Syntactic Abstraction
Code
Text
characters
Effect
Reader
data structures
characters
evaluator/
bytecode JVM
compiler
data structures
You
Program data structures
Program
(macro)
18. Expressions
• Everything is an expression
• All data literals represent themselves
• Except:
• Symbols
• looks for binding to value, locally,
then globally
• Lists
• An operation form
19. Operation forms
• (op ...)
• op can be either:
• one of very few special ops
• macro
• expression which yields a function
20. Special ops
• Can have non-normal evaluation of arguments
• (def name value-expr)
• establishes a global variable
• (if test-expr then-expr else-expr)
• conditional, evaluates only one of then/
else
• fn let loop recur do new . throw try
set! quote var
21. Macros
• Supplied with Clojure, and defined by user
• Argument forms are passed as data to the
macro function, which returns a new data
structure as a replacement for the macro call
• (or x y)
(let [or__158 x]
• becomes: (if or__158 or__158 y))
• Many things that are ‘built-in’ to other languages
are just macros in Clojure
22. Functions
• First-class values
(def five 5)
(def sqr (fn [x] (* x x)))
(sqr five)
25
• Maps are functions of their keys
(def m {:fred :ethel :ricky :lucy})
(m :fred)
:ethel
23. Syntax Summary
• Things that would be declarations, control
structures, function calls, operators, are all
just lists with op at front:
Java Clojure
int i = 5; (def i 5)
if(x == 0) (if (zero? x)
return y; y
else z)
return z;
x* y * z; (* x y z)
foo(x, y, z); (foo x y z)
foo.bar(x); (. foo bar x)
24. Sequences
• Abstraction of traditional Lisp lists
• (seq coll)
• if collection is non-empty, return seq
object on it, else nil
• (first seq)
• returns the first element
• (rest seq)
• returns a seq of the rest of the elements,
or nil if no more
26. Java Interop
(. Math PI)
3.141592653589793
(.. System getProperties (get "java.version"))
"1.5.0_13"
(new java.util.Date)
Thu Jun 05 12:37:32 EDT 2008
(doto (JFrame.) (add (JLabel. "Hello World")) pack show)
;expands to:
(let* [G__1837 (JFrame.)]
(do (. G__1837 (add (JLabel. "Hello World")))
(. G__1837 pack)
(. G__1837 show))
G__1837)
27. Java Integration
• Clojure strings are Java Strings, numbers are
Numbers, collections implement Collection,
fns implement Callable and Runnable etc.
• Core abstractions, like seq, are Java interfaces
• Clojure seq library works on Java Iterables,
Strings and arrays.
• Implement and extend Java interfaces and
classes
• New primitive arithmetic support equals
Java’s speed.
29. Functional Programming
• Immutable data + first-class functions
• Functions produce same output given same
input, and are free of side effects
• Could always be done by discipline/convention
• Pure functional languages tend to strongly static
types (ML, Haskell)
• Not for everyone, or every task
• Dynamic functional languages are rarer
• Clojure, Erlang
30. Why Functional Programming?
• Easier to reason about
• Easier to test
• Essential for concurrency (IMO)
• Java Concurrency in Practice - Goetz
• Additional benefits for purely functional
languages (static analysis, proof, program
transformation), but not Clojure
31. Which Functional Language?
• Fewer choices on the JVM
• CAL
• Haskell-like, strong type system
• Scala
• Type system, but immutability optional
• Clojure
• Dynamic types, immutable data
32. Persistent Data Structures
• Immutable, + old version of the collection is
still available after 'changes'
• Collection maintains its performance
guarantees for most operations
• Therefore new versions are not full copies
• All Clojure data structures persistent
• Hash map and vector both based upon
array mapped hash tries (Bagwell)
• Sorted map is red-black tree
33. Structural Sharing
• Key to efficient ‘copies’ and therefore
persistence
• Everything is final so no chance of
interference
• Thread safe
• Iteration safe
34. Path Copying
HashMap
HashMap
int count 16
int count 15
INode root
INode root
35. Concurrency
• Interleaved/simultaneous execution
• Must avoid seeing/yielding inconsistent data
• The more components there are to the data,
the more difficult to keep consistent
• The more steps in a logical change, the more
difficult to keep consistent
• Opportunities for automatic parallelism
• Emphasis here on coordination
36. State - You’re doing it wrong
• Mutable objects are the new spaghetti code
• Hard to understand, test, reason about
• Concurrency disaster
• Terrible default architecture (Java/C#/
Python/Ruby/Groovy/CLOS...)
• Doing the right thing is very difficult
• Languages matter!
37. Concurrency Methods
• Conventional way:
• Direct references to mutable objects
• Lock and worry (manual/convention)
• Clojure way:
• Indirect references to immutable persistent data
structures
• Concurrency semantics for references
• Automatic/enforced
• No locks!
38. Direct references to
Mutable Objects
?
?
42
?
6
Ensuring a consistent Object is on your head
39. Indirect references to
Immutable Objects
"fred"
"ethel"
42
17
6
Never an inconsistent Object
42. Clojure References
• The only things that mutate are references
themselves, in a controlled way
• 3 types of mutable references
• Vars - Isolate changes within threads
• Refs - Share synchronous coordinated
changes between threads
• Agents - Share asynchronous
independent changes between threads
43. Refs and Transactions
• Software transactional memory system (STM)
• Refs can only be changed within a transaction
• All changes are Atomic and Isolated
• Every change to Refs made within a
transaction occurs or none do
• No transaction sees the effects of any
other transaction while it is running
• Transactions are speculative
• Will be retried automatically if conflict
• Must avoid side-effects!
44. Concurrency Demo
• Ant colony simulation
• World populated with food and ants
• Ants find food, bring home, drop pheromones
• Sense pheromones, food, home
• Ants act independently, on multiple real threads
• Model pheromone evaporation
• Animated GUI
• < 250 lines of Clojure
45. And much more!
• Metadata
• Recursive functional looping
• Destructuring binding in let/fn/loop
• List comprehensions (for)
• Relational set algebra
• Multimethods
• Parallel computation
• Namespaces, zippers, XML ...