Open Source Compiler Construction for the JVM [LCA2011 Miniconf]
•Download as ODP, PDF•
1 like•996 views
The document discusses compiler construction for the JVM, including defining a grammar for a "Hello World" program, representing the program as an AST using Scala case classes, and compiling the AST to JVM bytecode using BCEL. Key points covered are defining grammars with parser combinators in Scala, representing the parse tree as an AST, and generating JVM bytecode from the AST.
Report
Share
Report
Share
![Compiler Construction for the JVM Tom Lee [email_address] Senior Consultant Shine Technologies http://www.shinetech.com](https://image.slidesharecdn.com/jvm-compiler-construction-110127055432-phpapp01/85/Open-Source-Compiler-Construction-for-the-JVM-LCA2011-Miniconf-1-320.jpg)
![Overview ,[object Object]](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)
Recommended
Return Oriented Programming (ROP) Based Exploits - Part I
Return Oriented Programming (ROP) Based Exploits - Part I by Anish & Team @ null B'lore Meet in September, 2010
Advance ROP Attacks
This document discusses return-oriented programming (ROP) attacks and variants. It begins with an introduction to ROP attacks, explaining that they circumvent data execution prevention by chaining small snippets of executable code (called gadgets) that end in return instructions. It then covers different ROP attack techniques like using arithmetic, comparison, and loop gadgets to achieve Turing completeness. The document discusses challenges like handling null bytes and describes variants like jump-oriented programming (JOP) that uses indirect jumps. It also covers creating alphanumeric ROP shellcode by selecting printable addresses. In the end, it provides tips for effectively searching gadgets.
Kotlin DSLs
This document discusses domain-specific languages (DSLs) in Kotlin. It provides examples of embedded DSLs in Kotlin for HTML, JSON, and Gradle. It explains how to build your own DSLs in Kotlin using extension functions, lambda expressions with receivers, and DSL markers to control scope. Finally, it discusses using the invoke operator to make DSL syntax more concise.
An introduction to ROP
Slides from my workshop at Hack.LU 2010 in Luxembourg. This workshop introduced the basic concepts of Return Oriented Programming with some hands-on exercises.
Dive into ROP - a quick introduction to Return Oriented Programming
The document introduces Return Oriented Programming (ROP) and its core concepts. It discusses how Data Execution Prevention (DEP) prevents execution of injected shellcode by marking the stack and heap as non-executable. ROP overcomes this by chaining together small snippets of existing code (called "gadgets") in libraries and binaries to achieve arbitrary code execution. This is done by creating fake stack frames and controlling the instruction pointer (EIP) to return to addresses of gadgets. An example demonstrates overflowing a function and making it return to another function by placing a fake stack frame.
Kotlin
This document compares the Kotlin and Swift programming languages. It provides an overview of key features of each language such as variables, functions, classes, inheritance, protocols/traits, enums, null safety, type checks and extensions. It also includes code examples to illustrate similarities and differences between the two languages. The document concludes with a comparison of other features and a diagram showing how each language fits into a typical mobile application architecture.
The Kotlin Programming Language
The document introduces the Kotlin programming language developed by JetBrains. It provides an overview of Kotlin's motivation, features, syntax and tooling. Key points include Kotlin being a statically typed JVM language intended for industrial use, its focus on common sense features from other languages, and full interoperability with Java.
Lean way write asynchronous code with Kotlin’s coroutines - Ronen Sabag, Gett
Kotlin's coroutines provide a way to write asynchronous code in a sequential manner using suspending functions and coroutines. The document provides examples of how coroutines can be used to make parallel network calls and pre-fetch data. Coroutines allow asynchronous tasks to be expressed sequentially through suspending functions and avoid callbacks. They integrate well with other frameworks like RxJava and provide an alternative to writing asynchronous code with callbacks.
Recommended
Return Oriented Programming (ROP) Based Exploits - Part I
Return Oriented Programming (ROP) Based Exploits - Part I by Anish & Team @ null B'lore Meet in September, 2010
Advance ROP Attacks
This document discusses return-oriented programming (ROP) attacks and variants. It begins with an introduction to ROP attacks, explaining that they circumvent data execution prevention by chaining small snippets of executable code (called gadgets) that end in return instructions. It then covers different ROP attack techniques like using arithmetic, comparison, and loop gadgets to achieve Turing completeness. The document discusses challenges like handling null bytes and describes variants like jump-oriented programming (JOP) that uses indirect jumps. It also covers creating alphanumeric ROP shellcode by selecting printable addresses. In the end, it provides tips for effectively searching gadgets.
Kotlin DSLs
This document discusses domain-specific languages (DSLs) in Kotlin. It provides examples of embedded DSLs in Kotlin for HTML, JSON, and Gradle. It explains how to build your own DSLs in Kotlin using extension functions, lambda expressions with receivers, and DSL markers to control scope. Finally, it discusses using the invoke operator to make DSL syntax more concise.
An introduction to ROP
Slides from my workshop at Hack.LU 2010 in Luxembourg. This workshop introduced the basic concepts of Return Oriented Programming with some hands-on exercises.
Dive into ROP - a quick introduction to Return Oriented Programming
The document introduces Return Oriented Programming (ROP) and its core concepts. It discusses how Data Execution Prevention (DEP) prevents execution of injected shellcode by marking the stack and heap as non-executable. ROP overcomes this by chaining together small snippets of existing code (called "gadgets") in libraries and binaries to achieve arbitrary code execution. This is done by creating fake stack frames and controlling the instruction pointer (EIP) to return to addresses of gadgets. An example demonstrates overflowing a function and making it return to another function by placing a fake stack frame.
Kotlin
This document compares the Kotlin and Swift programming languages. It provides an overview of key features of each language such as variables, functions, classes, inheritance, protocols/traits, enums, null safety, type checks and extensions. It also includes code examples to illustrate similarities and differences between the two languages. The document concludes with a comparison of other features and a diagram showing how each language fits into a typical mobile application architecture.
The Kotlin Programming Language
The document introduces the Kotlin programming language developed by JetBrains. It provides an overview of Kotlin's motivation, features, syntax and tooling. Key points include Kotlin being a statically typed JVM language intended for industrial use, its focus on common sense features from other languages, and full interoperability with Java.
Lean way write asynchronous code with Kotlin’s coroutines - Ronen Sabag, Gett
Kotlin's coroutines provide a way to write asynchronous code in a sequential manner using suspending functions and coroutines. The document provides examples of how coroutines can be used to make parallel network calls and pre-fetch data. Coroutines allow asynchronous tasks to be expressed sequentially through suspending functions and avoid callbacks. They integrate well with other frameworks like RxJava and provide an alternative to writing asynchronous code with callbacks.
Introduction to Ecmascript - ES6
This document provides an introduction and overview of ECMAScript 6 (ES6), the latest version of JavaScript. It discusses setting up the development environment with Node.js and npm. Key ES6 features covered include arrow functions, block scoping, template literals, destructuring, classes, modules, and promises. The document consists of 9 lectures with demonstrations of these new JavaScript features. It aims to help readers learn the major updates and capabilities introduced in ES6.
Course lecture - An introduction to the Return Oriented Programming
This document provides an introduction and overview of Return Oriented Programming (ROP). It discusses classical stack overflow attacks and the mitigations put in place like Address Space Layout Randomization (ASLR) and No eXecute (NX) bit. It then introduces ROP as a technique to bypass these mitigations by chaining small snippets of existing code, called gadgets, to perform malicious tasks without injecting code. Several tools for finding gadgets are presented, and an example exploitation of the CVE-2011-1938 vulnerability is discussed to demonstrate ROP in practice. The document concludes with discussing mitigations against ROP and some related research topics.
Erlang For Five Nines
The document summarizes the history and features of the Erlang programming language. It discusses how Erlang was developed at Ericsson in the 1980s to build robust, distributed telecom systems. It highlights Erlang's strengths like concurrency, distribution, hot code loading and fault tolerance. Examples are given of large Erlang projects at Ericsson and how the language enables high reliability, scalability and productivity. Popular open source and commercial products using Erlang are also listed.
JavaScript - new features in ECMAScript 6
This document discusses new features coming to JavaScript in ECMAScript 6, including:
1) Block scope keywords "let" and "const" that allow for block-level scoping of variables.
2) Shorthand syntax for object literals and method definitions.
3) Destructuring assignments for extracting values from objects and arrays.
4) Default parameter values, rest parameters, and spread syntax for working with functions and arrays.
5) New features like modules, classes, and imports for better organizing code.
Introduction to Debuggers
A quick tutorial on what debuggers are and how to use them. We present a debugging example using GDB. At the end of this tutorial, you will be able to work your way through a crash and analyze the cause of the error responsible for the crash.
effective_r27
The document summarizes key points from a presentation titled "Effective Python Programming - OSCON 2005". It discusses Python fundamentals like namespaces, duck typing and exceptions. It also covers structured programming techniques in Python like iterators, generators, for/else loops and try/finally blocks. The presentation emphasizes writing effective code that makes use of Python features and follows best practices.
eMan Dev Meetup: Kotlin - A Language we should know it exists (part 02/03) 18...
This document provides an overview of the Kotlin programming language. It defines Kotlin as a statically typed language that targets the JVM and JavaScript, is 100% interoperable with Java, and was created by JetBrains as a better alternative to Java. The document then covers 10 features of Kotlin, including null safety, data classes, extension functions, smart casts, and support for functional programming patterns. It provides code examples to demonstrate how these features work in Kotlin.
Ast transformation
Groovy's AST Transformation is a compile time meta-programming technique and allows developer to hook into compilation process and add new fields or methods, or modify existing methods.
How Xslate Works
- Xslate is a template engine for Perl5 that is written in C using XS. It aims to be fast, safe from XSS attacks, and support multiple template syntaxes including Kolon and TTerse.
- Xslate templates are first preprocessed, parsed into an AST, compiled into bytecode, and then executed by a virtual machine for high performance. Automatic HTML escaping also helps prevent XSS issues.
- Future goals include adding features like loop controls and context controls, as well as exploring more template syntaxes and better integrations with web frameworks.
Domain Specific Languages In Scala Duse3
Presentation on creating DSLs with Scala 2.8 which I presented at the Dutch Scala Enthousiasts meeting at Ebay/Marktplaats
An Annotation Framework for Statically-Typed Syntax Trees
This document presents an annotation framework for statically typed syntax trees that allows generating parsers and abstract syntax trees from annotated context-free grammars. Key contributions include a grammar-independent annotation approach, a definition of statically typed AST specifications, and a prototype parser generator. The framework uses annotations to specify the types of values nodes produce, supporting scalar, string, node reference, and list values. An example grammar for a simple language is annotated to demonstrate the approach. The prototype implementation generates scanners, parsers producing the specified ASTs, AST node classes, and visitor code from annotated grammars.
Open Source Compiler Construction for the JVM
This document discusses building a compiler for a simple language called "Awesome" that targets the Java Virtual Machine (JVM). It recommends writing a stub code generator first for quick feedback before building the full compiler. The compiler will use Scala parser combinators to parse the input into an abstract syntax tree (AST) and then walk the AST to generate equivalent JVM bytecode using the Bytecode Engineering Library (BCEL). The document outlines the overall compiler architecture and next steps to expand the language features supported by the compiler.
Introduction To Groovy 2005
The document introduces dynamic languages and provides examples comparing Java and Groovy implementations of a filtering task. It discusses the benefits of Groovy, including its Java-like syntax, dynamic typing, built-in support for lists/maps/arrays, closures, and additional libraries that simplify APIs. Groovy aims to integrate well with Java while adding meta-programming capabilities. The document provides examples of common uses of Groovy and its features.
Code documentation
This document discusses the importance of comments in code. It provides reasons to include comments such as explaining unintuitive code, documenting what the code is doing, and documenting why certain approaches were taken. It also discusses what makes a good comment, including commenting on processing, APIs, changes, tags, and keywords like TODO, FIXME, and XXX. Bad commenting practices like redundant comments are also covered. The document recommends commenting code for other programmers and notes comments are also important for documentation standards like JavaDoc and PHPDoc.
Type script - advanced usage and practices
This document provides an overview of advanced TypeScript concepts and best practices. It discusses the TypeScript toolchain and environment, ES2015+ features like let, modules, and unit testing. It covers the TypeScript type system including type inference, annotations, and strict checking. Other topics include decorators, structural typing, destructuring, and the differences between TypeScript and JavaScript.
Qcon2011 functions rockpresentation_scala
Scala functions provide powerful ways to decompose problems and harness the benefits of functional programming. The presentation introduces core concepts of functional programming using Scala as an example language, highlighting how Scala combines object-oriented and functional programming. It presents benefits like immutability, higher-order functions, and improved concurrency while avoiding past performance issues through modern virtual machines and libraries.
Don't Be Afraid of Abstract Syntax Trees
ASTs are an incredibly powerful tool for understanding and manipulating JavaScript. We'll explore this topic by looking at examples from ESLint, a pluggable static analysis tool, and Browserify, a client-side module bundler. Through these examples we'll see how ASTs can be great for analyzing and even for modifying your JavaScript. This talk should be interesting to anyone that regularly builds apps in JavaScript either on the client-side or on the server-side.
[Deprecated] Integrating libSyntax into the compiler pipeline
Please see the latest slide here
https://www.slideshare.net/kitasuke/integrating-libsyntax-into-the-compiler-pipeline-194152767
Swiftc meetup #13
Scala active record
This document provides an overview of Scala-ActiveRecord, a type-safe Active Record model library for Scala. It discusses features such as being type-safe, having Rails ActiveRecord-like functionality, automatic transaction control, and support for associations and validations. The document also covers getting started, defining schemas, CRUD operations, queries, caching queries, validations, callbacks, and relationships.
Introduction to Spark with Scala
Knoldus organized a Meetup on 1 April 2015. In this Meetup, we introduced Spark with Scala. Apache Spark is a fast and general engine for large-scale data processing. Spark is used at a wide range of organizations to process large datasets.
Es6 day1
This document outlines the key new features introduced in ES6 (ECMAScript 2015). It begins with an agenda that covers new syntax like let, const, arrow functions, default parameters, rest and spread operators, object literals, for-of loops, template literals, destructuring, classes, modules, and imports/exports. Each feature is then explained in more detail with examples, such as how let and const provide block scoping, arrow functions simplify function syntax, classes introduce OOP concepts to JavaScript, and modules standardize importing and exporting code.
Convention-Based Syntactic Descriptions
The document introduces a convention-based syntax notation designed for both humans and parser generators. Key aspects include using conventions to simplify EBNF notation, defining rules without delimiters, inferring token sets from rules, and representing abstract syntax trees with variables. The approach was motivated by limitations of existing formalisms. Examples are provided for microsyntax, macrosyntax, and representing abstract syntax trees. Future work discussed expanding the approach to support additional language features.
More Related Content
What's hot
Introduction to Ecmascript - ES6
This document provides an introduction and overview of ECMAScript 6 (ES6), the latest version of JavaScript. It discusses setting up the development environment with Node.js and npm. Key ES6 features covered include arrow functions, block scoping, template literals, destructuring, classes, modules, and promises. The document consists of 9 lectures with demonstrations of these new JavaScript features. It aims to help readers learn the major updates and capabilities introduced in ES6.
Course lecture - An introduction to the Return Oriented Programming
This document provides an introduction and overview of Return Oriented Programming (ROP). It discusses classical stack overflow attacks and the mitigations put in place like Address Space Layout Randomization (ASLR) and No eXecute (NX) bit. It then introduces ROP as a technique to bypass these mitigations by chaining small snippets of existing code, called gadgets, to perform malicious tasks without injecting code. Several tools for finding gadgets are presented, and an example exploitation of the CVE-2011-1938 vulnerability is discussed to demonstrate ROP in practice. The document concludes with discussing mitigations against ROP and some related research topics.
Erlang For Five Nines
The document summarizes the history and features of the Erlang programming language. It discusses how Erlang was developed at Ericsson in the 1980s to build robust, distributed telecom systems. It highlights Erlang's strengths like concurrency, distribution, hot code loading and fault tolerance. Examples are given of large Erlang projects at Ericsson and how the language enables high reliability, scalability and productivity. Popular open source and commercial products using Erlang are also listed.
JavaScript - new features in ECMAScript 6
This document discusses new features coming to JavaScript in ECMAScript 6, including:
1) Block scope keywords "let" and "const" that allow for block-level scoping of variables.
2) Shorthand syntax for object literals and method definitions.
3) Destructuring assignments for extracting values from objects and arrays.
4) Default parameter values, rest parameters, and spread syntax for working with functions and arrays.
5) New features like modules, classes, and imports for better organizing code.
Introduction to Debuggers
A quick tutorial on what debuggers are and how to use them. We present a debugging example using GDB. At the end of this tutorial, you will be able to work your way through a crash and analyze the cause of the error responsible for the crash.
effective_r27
The document summarizes key points from a presentation titled "Effective Python Programming - OSCON 2005". It discusses Python fundamentals like namespaces, duck typing and exceptions. It also covers structured programming techniques in Python like iterators, generators, for/else loops and try/finally blocks. The presentation emphasizes writing effective code that makes use of Python features and follows best practices.
eMan Dev Meetup: Kotlin - A Language we should know it exists (part 02/03) 18...
This document provides an overview of the Kotlin programming language. It defines Kotlin as a statically typed language that targets the JVM and JavaScript, is 100% interoperable with Java, and was created by JetBrains as a better alternative to Java. The document then covers 10 features of Kotlin, including null safety, data classes, extension functions, smart casts, and support for functional programming patterns. It provides code examples to demonstrate how these features work in Kotlin.
What's hot (7)
Course lecture - An introduction to the Return Oriented Programming
Course lecture - An introduction to the Return Oriented Programming
eMan Dev Meetup: Kotlin - A Language we should know it exists (part 02/03) 18...
eMan Dev Meetup: Kotlin - A Language we should know it exists (part 02/03) 18...
Similar to Open Source Compiler Construction for the JVM [LCA2011 Miniconf]
Ast transformation
Groovy's AST Transformation is a compile time meta-programming technique and allows developer to hook into compilation process and add new fields or methods, or modify existing methods.
How Xslate Works
- Xslate is a template engine for Perl5 that is written in C using XS. It aims to be fast, safe from XSS attacks, and support multiple template syntaxes including Kolon and TTerse.
- Xslate templates are first preprocessed, parsed into an AST, compiled into bytecode, and then executed by a virtual machine for high performance. Automatic HTML escaping also helps prevent XSS issues.
- Future goals include adding features like loop controls and context controls, as well as exploring more template syntaxes and better integrations with web frameworks.
Domain Specific Languages In Scala Duse3
Presentation on creating DSLs with Scala 2.8 which I presented at the Dutch Scala Enthousiasts meeting at Ebay/Marktplaats
An Annotation Framework for Statically-Typed Syntax Trees
This document presents an annotation framework for statically typed syntax trees that allows generating parsers and abstract syntax trees from annotated context-free grammars. Key contributions include a grammar-independent annotation approach, a definition of statically typed AST specifications, and a prototype parser generator. The framework uses annotations to specify the types of values nodes produce, supporting scalar, string, node reference, and list values. An example grammar for a simple language is annotated to demonstrate the approach. The prototype implementation generates scanners, parsers producing the specified ASTs, AST node classes, and visitor code from annotated grammars.
Open Source Compiler Construction for the JVM
This document discusses building a compiler for a simple language called "Awesome" that targets the Java Virtual Machine (JVM). It recommends writing a stub code generator first for quick feedback before building the full compiler. The compiler will use Scala parser combinators to parse the input into an abstract syntax tree (AST) and then walk the AST to generate equivalent JVM bytecode using the Bytecode Engineering Library (BCEL). The document outlines the overall compiler architecture and next steps to expand the language features supported by the compiler.
Introduction To Groovy 2005
The document introduces dynamic languages and provides examples comparing Java and Groovy implementations of a filtering task. It discusses the benefits of Groovy, including its Java-like syntax, dynamic typing, built-in support for lists/maps/arrays, closures, and additional libraries that simplify APIs. Groovy aims to integrate well with Java while adding meta-programming capabilities. The document provides examples of common uses of Groovy and its features.
Code documentation
This document discusses the importance of comments in code. It provides reasons to include comments such as explaining unintuitive code, documenting what the code is doing, and documenting why certain approaches were taken. It also discusses what makes a good comment, including commenting on processing, APIs, changes, tags, and keywords like TODO, FIXME, and XXX. Bad commenting practices like redundant comments are also covered. The document recommends commenting code for other programmers and notes comments are also important for documentation standards like JavaDoc and PHPDoc.
Type script - advanced usage and practices
This document provides an overview of advanced TypeScript concepts and best practices. It discusses the TypeScript toolchain and environment, ES2015+ features like let, modules, and unit testing. It covers the TypeScript type system including type inference, annotations, and strict checking. Other topics include decorators, structural typing, destructuring, and the differences between TypeScript and JavaScript.
Qcon2011 functions rockpresentation_scala
Scala functions provide powerful ways to decompose problems and harness the benefits of functional programming. The presentation introduces core concepts of functional programming using Scala as an example language, highlighting how Scala combines object-oriented and functional programming. It presents benefits like immutability, higher-order functions, and improved concurrency while avoiding past performance issues through modern virtual machines and libraries.
Don't Be Afraid of Abstract Syntax Trees
ASTs are an incredibly powerful tool for understanding and manipulating JavaScript. We'll explore this topic by looking at examples from ESLint, a pluggable static analysis tool, and Browserify, a client-side module bundler. Through these examples we'll see how ASTs can be great for analyzing and even for modifying your JavaScript. This talk should be interesting to anyone that regularly builds apps in JavaScript either on the client-side or on the server-side.
[Deprecated] Integrating libSyntax into the compiler pipeline
Please see the latest slide here
https://www.slideshare.net/kitasuke/integrating-libsyntax-into-the-compiler-pipeline-194152767
Swiftc meetup #13
Scala active record
This document provides an overview of Scala-ActiveRecord, a type-safe Active Record model library for Scala. It discusses features such as being type-safe, having Rails ActiveRecord-like functionality, automatic transaction control, and support for associations and validations. The document also covers getting started, defining schemas, CRUD operations, queries, caching queries, validations, callbacks, and relationships.
Introduction to Spark with Scala
Knoldus organized a Meetup on 1 April 2015. In this Meetup, we introduced Spark with Scala. Apache Spark is a fast and general engine for large-scale data processing. Spark is used at a wide range of organizations to process large datasets.
Es6 day1
This document outlines the key new features introduced in ES6 (ECMAScript 2015). It begins with an agenda that covers new syntax like let, const, arrow functions, default parameters, rest and spread operators, object literals, for-of loops, template literals, destructuring, classes, modules, and imports/exports. Each feature is then explained in more detail with examples, such as how let and const provide block scoping, arrow functions simplify function syntax, classes introduce OOP concepts to JavaScript, and modules standardize importing and exporting code.
Convention-Based Syntactic Descriptions
The document introduces a convention-based syntax notation designed for both humans and parser generators. Key aspects include using conventions to simplify EBNF notation, defining rules without delimiters, inferring token sets from rules, and representing abstract syntax trees with variables. The approach was motivated by limitations of existing formalisms. Examples are provided for microsyntax, macrosyntax, and representing abstract syntax trees. Future work discussed expanding the approach to support additional language features.
Scala in a nutshell by venkat
The document provides an overview of the Scala programming language. It begins with an agenda that outlines topics like differences between Java and Scala, Scala data types, variables, classes, functions, closures, exception handling and collections. It then discusses specific aspects of Scala like verbosity reduction compared to Java, functional programming influences, object-oriented features, interoperability with Java and compilation to Java bytecode. Examples are provided to illustrate Scala concepts like functions, classes, recursion, higher-order functions and exception handling. The document aims to explain Scala and reasons for differences from Java.
Introduction To Scala
Short introduction to the Scala programming language which I presented on the Ebay/Marktplaats Tech Tuesday
CQL performance with Apache Cassandra 3.0 (Aaron Morton, The Last Pickle) | C...
The 3.0 storage engine re-write is the biggest and most exciting change to ever happen in Apache Cassandra. The new storage engine can efficiently store and read data from disk using the same concepts present in the CQL 3 language. This has delivered large space savings, and creates new performance characteristics.
In this talk Aaron Morton, Co Founder at The Last Pickle and Apache Cassandra Committer, will discuss the 3.0 storage engine, it's layout and performance characteristics.
About the Speaker
Aaron Morton CEO, The Last Pickle
Aaron Morton is the Co Founder & CEO at The Last Pickle (thelastpickle.com). A professional services company that works with clients to deliver and improve Apache Cassandra based solutions. He's based in New Zealand, is an Apache Cassandra Committer and a DataStax MVP for Apache Cassandra.
Stepping Up : A Brief Intro to Scala
The Scala programming language has been gaining momentum recently as an alternative (and some might say successor) to Java on the JVM. This talk will start with an introduction to basic Scala syntax and concepts, then delve into some of Scala's more interesting and unique features. At the end we'll show a brief example of how Scala is used by the Lift web framework to simplify dynamic web apps.
Smoothing Your Java with DSLs
This document discusses how domain-specific languages (DSLs) can be used to make Java code more readable and maintainable. It describes different types of DSLs including external and internal DSLs built with Java and scripting languages. It also discusses JetBrains MPS, a language workbench that provides a new approach for building DSLs without relying on a specific output language. DSLs allow raising the level of abstraction and separating stable and changing parts of code. Fluent APIs and internal DSLs in Java provide readability benefits, while scripting languages allow further readability through features like closures and list literals.
Similar to Open Source Compiler Construction for the JVM [LCA2011 Miniconf] (20)
An Annotation Framework for Statically-Typed Syntax Trees
An Annotation Framework for Statically-Typed Syntax Trees
[Deprecated] Integrating libSyntax into the compiler pipeline
[Deprecated] Integrating libSyntax into the compiler pipeline
CQL performance with Apache Cassandra 3.0 (Aaron Morton, The Last Pickle) | C...
CQL performance with Apache Cassandra 3.0 (Aaron Morton, The Last Pickle) | C...
More from Tom Lee
A(n abridged) tour of the Rust compiler [PDX-Rust March 2014]
The document provides an overview of the major stages in Rust's compiler:
1) Scanning converts source code to tokens. Rust's scanner is in libsyntax/parse/lexer.rs.
2) Parsing converts tokens to an AST using grammar rules. Rust's parser is in libsyntax/parse/parser.rs and outputs an AST in libsyntax/ast.rs.
3) Semantic analysis applies Rust's rules through name resolution, type checking, borrow checking etc. This is handled by librustc/middle/*.rs.
4) Code generation translates the AST to LLVM IR. Rust uses librustc/middle/trans/base.rs and writes output with
Inside PHP [OSCON 2012]
My slides from "Inside PHP", a talk about how to change the syntax of the PHP programming language.
Modified PHP 5.4.4 source code (with the "until" keyword added during this presentation) is available here:
http://github.com/thomaslee/oscon2012-inside-php
Inside Python [OSCON 2012]
My slides from "Inside Python", a talk about how to change the syntax of the Python programming language.
Modified Python 3.2 source code (with the "unless" keyword added during this presentation) is available here:
http://github.com/thomaslee/oscon2012-inside-python
Open Source in Big Business [LCA2011 Miniconf]
This document provides advice for consultants on promoting open source software to big businesses. It suggests focusing on delivering value to clients over dogmatism. Open source allows flexibility and community support. The document recommends proving support for established open source solutions, convincing clients of total cost savings, and encouraging them to contribute code back to open source projects for mutual benefit.
Open Source in Big Business (OSDC 2010)
My OSDC 2010 presentation regarding my personal experience in working with Open Source in big corporations.
Hugging Abstract Syntax Trees: A Pythonic Love Story (OSDC 2010)
OSDC 2010 presentation on cool stuff that can be done with Python Abstract Syntax Trees and the compile() function.
Demo Python compiler (incomplete and hacky!) can be found here: http://github.com/thomaslee/viking-poc
Python Compiler Internals Presentation Slides
The document discusses implementing a new "unless" statement in the Python compiler. It covers modifying the grammar, changing the AST definition, and generating bytecode for the new statement. Key parts of the compiler like the tokenizer, parser, AST translation, and bytecode generation are affected. Sample code is shown for how "unless" would work similarly to "if not". The presentation encourages exploring compiler internals and not being afraid to ask questions.
More from Tom Lee (7)
A(n abridged) tour of the Rust compiler [PDX-Rust March 2014]
A(n abridged) tour of the Rust compiler [PDX-Rust March 2014]
Hugging Abstract Syntax Trees: A Pythonic Love Story (OSDC 2010)
Hugging Abstract Syntax Trees: A Pythonic Love Story (OSDC 2010)
Recently uploaded
Mutation Testing for Task-Oriented Chatbots
Conversational agents, or chatbots, are increasingly used to access all sorts of services using natural language. While open-domain chatbots - like ChatGPT - can converse on any topic, task-oriented chatbots - the focus of this paper - are designed for specific tasks, like booking a flight, obtaining customer support, or setting an appointment. Like any other software, task-oriented chatbots need to be properly tested, usually by defining and executing test scenarios (i.e., sequences of user-chatbot interactions). However, there is currently a lack of methods to quantify the completeness and strength of such test scenarios, which can lead to low-quality tests, and hence to buggy chatbots.
To fill this gap, we propose adapting mutation testing (MuT) for task-oriented chatbots. To this end, we introduce a set of mutation operators that emulate faults in chatbot designs, an architecture that enables MuT on chatbots built using heterogeneous technologies, and a practical realisation as an Eclipse plugin. Moreover, we evaluate the applicability, effectiveness and efficiency of our approach on open-source chatbots, with promising results.
"Scaling RAG Applications to serve millions of users", Kevin Goedecke
How we managed to grow and scale a RAG application from zero to thousands of users in 7 months. Lessons from technical challenges around managing high load for LLMs, RAGs and Vector databases.
GNSS spoofing via SDR (Criptored Talks 2024)
In the realm of cybersecurity, offensive security practices act as a critical shield. By simulating real-world attacks in a controlled environment, these techniques expose vulnerabilities before malicious actors can exploit them. This proactive approach allows manufacturers to identify and fix weaknesses, significantly enhancing system security.
This presentation delves into the development of a system designed to mimic Galileo's Open Service signal using software-defined radio (SDR) technology. We'll begin with a foundational overview of both Global Navigation Satellite Systems (GNSS) and the intricacies of digital signal processing.
The presentation culminates in a live demonstration. We'll showcase the manipulation of Galileo's Open Service pilot signal, simulating an attack on various software and hardware systems. This practical demonstration serves to highlight the potential consequences of unaddressed vulnerabilities, emphasizing the importance of offensive security practices in safeguarding critical infrastructure.
"$10 thousand per minute of downtime: architecture, queues, streaming and fin...
Direct losses from downtime in 1 minute = $5-$10 thousand dollars. Reputation is priceless.
As part of the talk, we will consider the architectural strategies necessary for the development of highly loaded fintech solutions. We will focus on using queues and streaming to efficiently work and manage large amounts of data in real-time and to minimize latency.
We will focus special attention on the architectural patterns used in the design of the fintech system, microservices and event-driven architecture, which ensure scalability, fault tolerance, and consistency of the entire system.
Leveraging the Graph for Clinical Trials and Standards
Katja Glaß
OpenStudyBuilder Community Manager - Katja Glaß Consulting
Marius Conjeaud
Principal Consultant - Neo4j
Northern Engraving | Nameplate Manufacturing Process - 2024
Manufacturing custom quality metal nameplates and badges involves several standard operations. Processes include sheet prep, lithography, screening, coating, punch press and inspection. All decoration is completed in the flat sheet with adhesive and tooling operations following. The possibilities for creating unique durable nameplates are endless. How will you create your brand identity? We can help!
inQuba Webinar Mastering Customer Journey Management with Dr Graham Hill
HERE IS YOUR WEBINAR CONTENT! 'Mastering Customer Journey Management with Dr. Graham Hill'. We hope you find the webinar recording both insightful and enjoyable.
In this webinar, we explored essential aspects of Customer Journey Management and personalization. Here’s a summary of the key insights and topics discussed:
Key Takeaways:
Understanding the Customer Journey: Dr. Hill emphasized the importance of mapping and understanding the complete customer journey to identify touchpoints and opportunities for improvement.
Personalization Strategies: We discussed how to leverage data and insights to create personalized experiences that resonate with customers.
Technology Integration: Insights were shared on how inQuba’s advanced technology can streamline customer interactions and drive operational efficiency.
Must Know Postgres Extension for DBA and Developer during Migration
Mydbops Opensource Database Meetup 16
Topic: Must-Know PostgreSQL Extensions for Developers and DBAs During Migration
Speaker: Deepak Mahto, Founder of DataCloudGaze Consulting
Date & Time: 8th June | 10 AM - 1 PM IST
Venue: Bangalore International Centre, Bangalore
Abstract: Discover how PostgreSQL extensions can be your secret weapon! This talk explores how key extensions enhance database capabilities and streamline the migration process for users moving from other relational databases like Oracle.
Key Takeaways:
* Learn about crucial extensions like oracle_fdw, pgtt, and pg_audit that ease migration complexities.
* Gain valuable strategies for implementing these extensions in PostgreSQL to achieve license freedom.
* Discover how these key extensions can empower both developers and DBAs during the migration process.
* Don't miss this chance to gain practical knowledge from an industry expert and stay updated on the latest open-source database trends.
Mydbops Managed Services specializes in taking the pain out of database management while optimizing performance. Since 2015, we have been providing top-notch support and assistance for the top three open-source databases: MySQL, MongoDB, and PostgreSQL.
Our team offers a wide range of services, including assistance, support, consulting, 24/7 operations, and expertise in all relevant technologies. We help organizations improve their database's performance, scalability, efficiency, and availability.
Contact us: info@mydbops.com
Visit: https://www.mydbops.com/
Follow us on LinkedIn: https://in.linkedin.com/company/mydbops
For more details and updates, please follow up the below links.
Meetup Page : https://www.meetup.com/mydbops-databa...
Twitter: https://twitter.com/mydbopsofficial
Blogs: https://www.mydbops.com/blog/
Facebook(Meta): https://www.facebook.com/mydbops/
"Choosing proper type of scaling", Olena Syrota
Imagine an IoT processing system that is already quite mature and production-ready and for which client coverage is growing and scaling and performance aspects are life and death questions. The system has Redis, MongoDB, and stream processing based on ksqldb. In this talk, firstly, we will analyze scaling approaches and then select the proper ones for our system.
Your One-Stop Shop for Python Success: Top 10 US Python Development Providers
Simplify your search for a reliable Python development partner! This list presents the top 10 trusted US providers offering comprehensive Python development services, ensuring your project's success from conception to completion.
Skybuffer SAM4U tool for SAP license adoption
Manage and optimize your license adoption and consumption with SAM4U, an SAP free customer software asset management tool.
SAM4U, an SAP complimentary software asset management tool for customers, delivers a detailed and well-structured overview of license inventory and usage with a user-friendly interface. We offer a hosted, cost-effective, and performance-optimized SAM4U setup in the Skybuffer Cloud environment. You retain ownership of the system and data, while we manage the ABAP 7.58 infrastructure, ensuring fixed Total Cost of Ownership (TCO) and exceptional services through the SAP Fiori interface.
Biomedical Knowledge Graphs for Data Scientists and Bioinformaticians
Dmitrii Kamaev, PhD
Senior Product Owner - QIAGEN
AppSec PNW: Android and iOS Application Security with MobSF
Mobile Security Framework - MobSF is a free and open source automated mobile application security testing environment designed to help security engineers, researchers, developers, and penetration testers to identify security vulnerabilities, malicious behaviours and privacy concerns in mobile applications using static and dynamic analysis. It supports all the popular mobile application binaries and source code formats built for Android and iOS devices. In addition to automated security assessment, it also offers an interactive testing environment to build and execute scenario based test/fuzz cases against the application.
This talk covers:
Using MobSF for static analysis of mobile applications.
Interactive dynamic security assessment of Android and iOS applications.
Solving Mobile app CTF challenges.
Reverse engineering and runtime analysis of Mobile malware.
How to shift left and integrate MobSF/mobsfscan SAST and DAST in your build pipeline.
Main news related to the CCS TSI 2023 (2023/1695)
An English 🇬🇧 translation of a presentation to the speech I gave about the main changes brought by CCS TSI 2023 at the biggest Czech conference on Communications and signalling systems on Railways, which was held in Clarion Hotel Olomouc from 7th to 9th November 2023 (konferenceszt.cz). Attended by around 500 participants and 200 on-line followers.
The original Czech 🇨🇿 version of the presentation can be found here: https://www.slideshare.net/slideshow/hlavni-novinky-souvisejici-s-ccs-tsi-2023-2023-1695/269688092 .
The videorecording (in Czech) from the presentation is available here: https://youtu.be/WzjJWm4IyPk?si=SImb06tuXGb30BEH .
Northern Engraving | Modern Metal Trim, Nameplates and Appliance Panels
What began over 115 years ago as a supplier of precision gauges to the automotive industry has evolved into being an industry leader in the manufacture of product branding, automotive cockpit trim and decorative appliance trim. Value-added services include in-house Design, Engineering, Program Management, Test Lab and Tool Shops.
Crafting Excellence: A Comprehensive Guide to iOS Mobile App Development Serv...
Crafting Excellence: A Comprehensive Guide to iOS Mobile App Development Serv...Pitangent Analytics & Technology Solutions Pvt. Ltd
Discover top-tier mobile app development services, offering innovative solutions for iOS and Android. Enhance your business with custom, user-friendly mobile applications.Monitoring and Managing Anomaly Detection on OpenShift.pdf
Monitoring and Managing Anomaly Detection on OpenShift
Overview
Dive into the world of anomaly detection on edge devices with our comprehensive hands-on tutorial. This SlideShare presentation will guide you through the entire process, from data collection and model training to edge deployment and real-time monitoring. Perfect for those looking to implement robust anomaly detection systems on resource-constrained IoT/edge devices.
Key Topics Covered
1. Introduction to Anomaly Detection
- Understand the fundamentals of anomaly detection and its importance in identifying unusual behavior or failures in systems.
2. Understanding Edge (IoT)
- Learn about edge computing and IoT, and how they enable real-time data processing and decision-making at the source.
3. What is ArgoCD?
- Discover ArgoCD, a declarative, GitOps continuous delivery tool for Kubernetes, and its role in deploying applications on edge devices.
4. Deployment Using ArgoCD for Edge Devices
- Step-by-step guide on deploying anomaly detection models on edge devices using ArgoCD.
5. Introduction to Apache Kafka and S3
- Explore Apache Kafka for real-time data streaming and Amazon S3 for scalable storage solutions.
6. Viewing Kafka Messages in the Data Lake
- Learn how to view and analyze Kafka messages stored in a data lake for better insights.
7. What is Prometheus?
- Get to know Prometheus, an open-source monitoring and alerting toolkit, and its application in monitoring edge devices.
8. Monitoring Application Metrics with Prometheus
- Detailed instructions on setting up Prometheus to monitor the performance and health of your anomaly detection system.
9. What is Camel K?
- Introduction to Camel K, a lightweight integration framework built on Apache Camel, designed for Kubernetes.
10. Configuring Camel K Integrations for Data Pipelines
- Learn how to configure Camel K for seamless data pipeline integrations in your anomaly detection workflow.
11. What is a Jupyter Notebook?
- Overview of Jupyter Notebooks, an open-source web application for creating and sharing documents with live code, equations, visualizations, and narrative text.
12. Jupyter Notebooks with Code Examples
- Hands-on examples and code snippets in Jupyter Notebooks to help you implement and test anomaly detection models.
Astute Business Solutions | Oracle Cloud Partner |
Your goto partner for Oracle Cloud, PeopleSoft, E-Business Suite, and Ellucian Banner. We are a firm specialized in managed services and consulting.
Recently uploaded (20)
"Scaling RAG Applications to serve millions of users", Kevin Goedecke
"Scaling RAG Applications to serve millions of users", Kevin Goedecke
"$10 thousand per minute of downtime: architecture, queues, streaming and fin...
"$10 thousand per minute of downtime: architecture, queues, streaming and fin...
Leveraging the Graph for Clinical Trials and Standards
Leveraging the Graph for Clinical Trials and Standards
Northern Engraving | Nameplate Manufacturing Process - 2024
Northern Engraving | Nameplate Manufacturing Process - 2024
inQuba Webinar Mastering Customer Journey Management with Dr Graham Hill
inQuba Webinar Mastering Customer Journey Management with Dr Graham Hill
Must Know Postgres Extension for DBA and Developer during Migration
Must Know Postgres Extension for DBA and Developer during Migration
Your One-Stop Shop for Python Success: Top 10 US Python Development Providers
Your One-Stop Shop for Python Success: Top 10 US Python Development Providers
Biomedical Knowledge Graphs for Data Scientists and Bioinformaticians
Biomedical Knowledge Graphs for Data Scientists and Bioinformaticians
AppSec PNW: Android and iOS Application Security with MobSF
AppSec PNW: Android and iOS Application Security with MobSF
Northern Engraving | Modern Metal Trim, Nameplates and Appliance Panels
Northern Engraving | Modern Metal Trim, Nameplates and Appliance Panels
Crafting Excellence: A Comprehensive Guide to iOS Mobile App Development Serv...
Crafting Excellence: A Comprehensive Guide to iOS Mobile App Development Serv...
Monitoring and Managing Anomaly Detection on OpenShift.pdf
Monitoring and Managing Anomaly Detection on OpenShift.pdf
Astute Business Solutions | Oracle Cloud Partner |
Astute Business Solutions | Oracle Cloud Partner |
Open Source Compiler Construction for the JVM [LCA2011 Miniconf]
- 1. Compiler Construction for the JVM Tom Lee [email_address] Senior Consultant Shine Technologies http://www.shinetech.com
- 3. Why target the JVM?
- 7. “Hello World” in AST form
- 8. Representing ASTs in Scala
- 9. Compiling ASTs with BCEL
- 10. A Small Proof of Concept
- 13. Compilation of ASTs within Python in 2.6
- 19. “Hello World” puts(“Hello World”);
- 20. “Hello World” (cont.) puts ( “Hello World” ) ;
- 21. “Hello World” (cont.) putsStmt -> “puts” “(“ str “)” “;” str -> STR STR -> regex(“[^”]*”)
- 22. “Hello World” (cont.) call -> name “(“ str “)” “;” name -> ID str -> STR ID -> regex([a-zA-Z_][a-zA-Z_0-9]*) STR -> regex(“[^”]*”)
- 23. “Hello World” (cont.) stmt -> expr “;” expr -> str | call call -> name “(“ args? “)” args -> expr ( “,” expr)* str -> STR name -> ID STR -> regex(“[^”]*”) ID -> regex([a-zA-Z_][a-zA-Z_0-9]*) By deriving these grammars, we make it easy to reproduce them in Scala. How?
- 26. Scala's Parser Combinators (cont.) expr -> str | call call -> name “(“ args? “)” “;” ... Grammar def expr = str | call def call = name ~ (“(“ ~> args? <~ “)”) “;” ... Scala
- 27. “Hello World” in AST form
- 28. “Hello World” in AST form (cont.) o_O For the sake of simplicity, we'll pretend all our programs consist of a single expression...
- 32. Case classes for everything else
- 33. Representing ASTs in Scala (cont.) trait AST {} // trait Stmt extends AST {} trait Expr extends AST {} case class Call(name : Name, args : List[Expr]) extends Expr case class Name(id : String) extends Expr case class Str(value : String) extends Expr
- 35. Generate logically equivalent bytecode
- 39. Convert it to its parser combinator equivalent
- 40. Act upon parse results to construct an AST
- 41. Generate logically equivalent JVM bytecode