This document summarizes the good, bad, and ugly aspects of Ecma TC39, the standards committee for JavaScript. The good includes many expert contributors who care deeply about the language, consensus-driven decision making, and balancing perspectives. The bad consists of competitive gaming, logrolling to advance individual interests, and premature complexity constraints. The ugly involves meta-discussions that can mask business agendas without specific arguments or evidence.
The document discusses the history and goals of JavaScript and the Harmony project. It provides a brief overview of JavaScript's origins and evolution from 1995 to the present. It then outlines the main goals of the Harmony project, which aims to create a better language for complex applications, libraries, and code generators. The document proceeds to summarize features that have been approved for inclusion in ES6, such as let/const block scoping, destructuring, default parameters, and iterators/generators. It also discusses other proposals under consideration, such as binary data types and quasi-literals for safer string interpolation.
My JSConf.eu presentation. Some recycling from CapitolJS, but new stuff in the middle on ES6 special forms triangle, monocle-mustache, classes (syntax in progress), and how the JS community can help.
The document summarizes the development of Scripted, a lightweight browser-based code editor. It discusses observations that heavy IDEs are not ideal for JavaScript development and speed is essential. Two prototypes were created - Orion and Scripted. Scripted focused on speed, code awareness through static analysis, and module system comprehension. Near term goals include improved content assistance and a plugin model. Long term goals include debugging integration and support for additional languages.
Stop Building It From Scratch: Creating Reusable eLearning ComponentsChad Udell
Is your organization constantly going through the same development path to produce your e-Learning... rehashing the same code, digging through line after line of spaghetti, and not seeing any real reuse benefits? If you want to leverage your intellectual property, and put your toolset to work for you, come ready to take note of practical tools, tips, and techniques you can employ immediately to enjoy productivity benefits.
In this session, you’ll learn secrets that Rapid Development gurus use. If you are tired of simple tools that speed up development, but really tie your hands when it comes to true customization, you need to learn more about application programming interfaces (APIs). The Web 2.0 world has largely been shaped by the emergence of Web services and the dominance of XML, yet so few e Learning development programs allow you to tap into those powerful tools. You’ll leave this session with ideas on how to build your own APIs, or use preexisting ones, right away.
In this session, you will learn:
* The benefits of building content in a reusable format
* Practical examples of reusable e-Learning concepts
* How to apply object-oriented development techniques to e-Learning
* What APIs are, and how you can use them to speed up development
* Techniques for designing your own e-Learning APIs
* Designing data schemas for flexibility
Audience:
Advanced designers and developers with basic programming skills in ActionScript, and who have edited XML. Deeper understanding of XML concepts and terminology will assist in greater understanding of this topic.
This document provides an overview of a presentation titled "The ROR Trilogy Part I: A New Dev Hope" given by Amir Barylko. The presentation introduces Ruby and Ruby on Rails (ROR), covering topics such as dynamic languages, Ruby features, classes and objects, mixins, ROR conventions like MVC and scaffolding. It also lists resources for learning Ruby and ROR and concludes with a demo of a movie library application.
Alfresco provides many extensions points for building custom solutions, integrating with a multitude of different tools. Learn how Alfresco’s Integration Engineering team has approached building integrations with Jive and Dropbox. See what’s coming around the bend and how you can participate with community lead integration projects.
This document summarizes the good, bad, and ugly aspects of Ecma TC39, the standards committee for JavaScript. The good includes many expert contributors who care deeply about the language, consensus-driven decision making, and balancing perspectives. The bad consists of competitive gaming, logrolling to advance individual interests, and premature complexity constraints. The ugly involves meta-discussions that can mask business agendas without specific arguments or evidence.
The document discusses the history and goals of JavaScript and the Harmony project. It provides a brief overview of JavaScript's origins and evolution from 1995 to the present. It then outlines the main goals of the Harmony project, which aims to create a better language for complex applications, libraries, and code generators. The document proceeds to summarize features that have been approved for inclusion in ES6, such as let/const block scoping, destructuring, default parameters, and iterators/generators. It also discusses other proposals under consideration, such as binary data types and quasi-literals for safer string interpolation.
My JSConf.eu presentation. Some recycling from CapitolJS, but new stuff in the middle on ES6 special forms triangle, monocle-mustache, classes (syntax in progress), and how the JS community can help.
The document summarizes the development of Scripted, a lightweight browser-based code editor. It discusses observations that heavy IDEs are not ideal for JavaScript development and speed is essential. Two prototypes were created - Orion and Scripted. Scripted focused on speed, code awareness through static analysis, and module system comprehension. Near term goals include improved content assistance and a plugin model. Long term goals include debugging integration and support for additional languages.
Stop Building It From Scratch: Creating Reusable eLearning ComponentsChad Udell
Is your organization constantly going through the same development path to produce your e-Learning... rehashing the same code, digging through line after line of spaghetti, and not seeing any real reuse benefits? If you want to leverage your intellectual property, and put your toolset to work for you, come ready to take note of practical tools, tips, and techniques you can employ immediately to enjoy productivity benefits.
In this session, you’ll learn secrets that Rapid Development gurus use. If you are tired of simple tools that speed up development, but really tie your hands when it comes to true customization, you need to learn more about application programming interfaces (APIs). The Web 2.0 world has largely been shaped by the emergence of Web services and the dominance of XML, yet so few e Learning development programs allow you to tap into those powerful tools. You’ll leave this session with ideas on how to build your own APIs, or use preexisting ones, right away.
In this session, you will learn:
* The benefits of building content in a reusable format
* Practical examples of reusable e-Learning concepts
* How to apply object-oriented development techniques to e-Learning
* What APIs are, and how you can use them to speed up development
* Techniques for designing your own e-Learning APIs
* Designing data schemas for flexibility
Audience:
Advanced designers and developers with basic programming skills in ActionScript, and who have edited XML. Deeper understanding of XML concepts and terminology will assist in greater understanding of this topic.
This document provides an overview of a presentation titled "The ROR Trilogy Part I: A New Dev Hope" given by Amir Barylko. The presentation introduces Ruby and Ruby on Rails (ROR), covering topics such as dynamic languages, Ruby features, classes and objects, mixins, ROR conventions like MVC and scaffolding. It also lists resources for learning Ruby and ROR and concludes with a demo of a movie library application.
Alfresco provides many extensions points for building custom solutions, integrating with a multitude of different tools. Learn how Alfresco’s Integration Engineering team has approached building integrations with Jive and Dropbox. See what’s coming around the bend and how you can participate with community lead integration projects.
This document discusses how Pragmatic Smalltalk aims to allow Smalltalk code to play well with other languages by compiling to native code compatible with Objective-C. It describes how Smalltalk code can directly call C functions and interoperate with Objective-C code and libraries. Key aspects covered include compiling Smalltalk blocks and memory management to be compatible with Objective-C, and allowing Smalltalk code to be used from the terminal and shell scripts.
- JavaScript has come a long way in its 16 year history, from its origins in 1995 at Netscape to becoming a core technology powering modern web applications.
- It was created in just 10 days by Brendan Eich to add interactivity to web pages and competed with Java for browser dominance, though it faced early criticism over its design choices and lack of features.
- JavaScript now has widespread adoption across browsers and continues evolving through standards like ES.next while also facing ongoing debates around issues like bytecode compilation and multi-virtual machine integration.
The economies of scaling software - Abdel Remanijaxconf
This document discusses quantifying the scalability of software. It recommends instrumenting code from the beginning to collect monitoring data on application health, the entire cluster, and individual nodes' system resources. This allows measuring how well a system can handle increasing load and evolving constraints.
This document discusses the process of using Gherkin scripts to automate acceptance testing over multiple iterations of a project. Key points include:
- Gherkins were used to define test cases and acceptance criteria from the start of development.
- Automated testing was implemented in stages, first manually running Gherkins then gradually automating more test cases across browsers and environments.
- The process evolved to include capturing screenshots, archiving results, and coordinating test execution with various teams.
- Future areas for improvement include expanding test coverage, simplifying maintenance, and generating Gherkins from models.
This document discusses using the F# programming language for shell scripting. It provides background on shell scripting and functional programming concepts in F#. It then gives examples of F# code for shell scripting, including how to pass command line arguments. Finally, it lists additional resources for learning more about scripting with F#.
This document appears to be notes from a presentation or talk. It discusses various topics related to Plone, a content management system, including its vision, customers as developers, theories of web development, what makes a good development tool, who Plone currently solves problems for, issues with Buildout and the database, minimizing knowledge and steps needed, and developing by default. The document advocates for making Plone more accessible and developable out of the box.
The document discusses high quality iOS development, covering topics like memory management using retain counts, autorelease pools, and ownership rules. It emphasizes avoiding memory leaks and crashes through best practices like analyzing code with Instruments and Clang static analyzer. Crash reports are also discussed as a way to identify and resolve issues in beta testing and released apps.
This document summarizes Jake Smith's presentation on micro-frameworks for PHP given at Dallas PHP on 4/12/2011. It introduces Jake and the topic of micro-frameworks, then provides overviews of several popular PHP micro-frameworks: Minimum, Silex, Limonade, and Slim. For each framework, it lists the website, required PHP version, provides a brief example app, and calls out pros and cons. The goal is to help attendees understand what micro-frameworks are and compare options.
This document discusses different types of extensions for Rails including plugins, gems, and initializers. It notes that gems are now preferred over plugins and provides tips for evaluating the quality of extensions, such as checking activity levels on RubyGems, GitHub, mailing lists, and issue lists. Using gems is often as simple as adding them to the gemfile and running bundle install.
The document discusses how Ruby on Rails (RoR) helped during floods in Australia. It describes how Heroku, a Platform as a Service (PaaS), allows developers to deploy RoR applications using a git-based workflow. Heroku manages web and background processes (dynos and workers) and allows scaling by adding more dynos to handle requests.
The document discusses BoxGrinder, a tool for creating virtual machine appliances from definition files. It describes how appliance definitions work, including general information, hardware requirements, package lists, and mixins. The document also provides an overview of BoxGrinder's build architecture which uses plugins to build appliances from definition files and deliver them to various platforms.
The document discusses different types of software tests and their purposes. It suggests that unit tests should focus on verifying correctness through line and branch coverage and gaining confidence in individual functions. Integration tests are best for experimenting with third-party code but may be a waste of time testing functionality that is not your own. Functional tests work well early in development to verify requirements and key features but may do too much as code changes rapidly.
Introducing the Ceylon Project - Gavin King presentation at QCon Beijing 2011devstonez
The document introduces the Ceylon project, which is designing a new programming language and SDK that addresses frustrations with Java while retaining its successes. The Ceylon project aims to create a language that runs on the JVM, has static typing, automatic memory management, and is readable like Java, but also includes first-class functions, a declarative syntax for defining user interfaces and data, built-in modularity, and addresses issues in the Java SDK. The presentation provides a brief overview of the Ceylon language through a simple "Hello World" example to demonstrate features like annotations, string interpolation, default parameters, and handling nullable values without NullPointerExceptions.
The document introduces the Ceylon project, which aims to design a new programming language and SDK that addresses frustrations with Java while retaining its successes. It was started by Gavin King and his team who have been developing Java frameworks for 10 years. Ceylon will run on the JVM and feature static typing, automatic memory management, and first-class functions while being readable like Java. Gavin provides some examples of Ceylon's syntax including classes, sequences, higher-order functions, and named arguments to demonstrate how it addresses issues in Java. The project is not yet available publicly and this talk is the first public discussion of Ceylon.
2011 JavaOne Apache TomEE Java EE 6 Web ProfileDavid Blevins
Apache TomEE is a Java EE 6 Web Profile certified application server built on top of Tomcat. It includes Apache components like MyFaces, OpenWebBeans, OpenEJB, OpenJPA, and Bean Validation. The entire Web Profile is only 24MB in size and has a small memory footprint. It aims to prove that a certified Java EE stack can be lightweight and agile. Future goals include further optimizations to reduce size and improve performance.
JRuby allows developers to use the Ruby programming language on the Java Virtual Machine. It provides a solid, reliable implementation of Ruby that integrates well with existing Java libraries and tools. JRuby brings the features of Ruby like its elegant syntax to Java developers, while also bringing the large Java ecosystem to Ruby developers. It allows both communities to work together on the same platform.
This document summarizes a presentation about using JRuby in the enterprise. It introduces the speaker and asks the audience about their backgrounds with Ruby, Rails, Java, and JRuby. It then discusses reasons for using JRuby, including better threading support, performance, Java integration, and leveraging existing Java knowledge. It demonstrates Java integration by creating a simple Swing application in Ruby. It also discusses a case study and upcoming features in JRuby 1.4 RC1.
Kendall Clark, CEO of Clark & Parsia, LLC, presented an overview of their new RDF database called Stardog. Key points include that Stardog is fast, lightweight, supports rich APIs, logical and statistical inference, and full-text search. It aims to be the fastest RDF database and supports OWL 2 reasoning and SPARQL queries. Stardog is currently in alpha testing and plans to launch a private beta in early April ahead of its 1.0 release in mid-summer.
The document discusses new features coming to JavaScript in the future. It describes CoffeeScript and compiling ES.next to current JavaScript as ways to experiment with these new features. It lists some approved features for ES.next, including block scope variables, destructuring, default parameters, rest/spread syntax, proxies, weak maps, modules, and iterators/generators. The document also discusses goals for ES.next such as being better for complex apps, libraries, and code generators while keeping versions simple and supporting a secure subset.
This document discusses how Pragmatic Smalltalk aims to allow Smalltalk code to play well with other languages by compiling to native code compatible with Objective-C. It describes how Smalltalk code can directly call C functions and interoperate with Objective-C code and libraries. Key aspects covered include compiling Smalltalk blocks and memory management to be compatible with Objective-C, and allowing Smalltalk code to be used from the terminal and shell scripts.
- JavaScript has come a long way in its 16 year history, from its origins in 1995 at Netscape to becoming a core technology powering modern web applications.
- It was created in just 10 days by Brendan Eich to add interactivity to web pages and competed with Java for browser dominance, though it faced early criticism over its design choices and lack of features.
- JavaScript now has widespread adoption across browsers and continues evolving through standards like ES.next while also facing ongoing debates around issues like bytecode compilation and multi-virtual machine integration.
The economies of scaling software - Abdel Remanijaxconf
This document discusses quantifying the scalability of software. It recommends instrumenting code from the beginning to collect monitoring data on application health, the entire cluster, and individual nodes' system resources. This allows measuring how well a system can handle increasing load and evolving constraints.
This document discusses the process of using Gherkin scripts to automate acceptance testing over multiple iterations of a project. Key points include:
- Gherkins were used to define test cases and acceptance criteria from the start of development.
- Automated testing was implemented in stages, first manually running Gherkins then gradually automating more test cases across browsers and environments.
- The process evolved to include capturing screenshots, archiving results, and coordinating test execution with various teams.
- Future areas for improvement include expanding test coverage, simplifying maintenance, and generating Gherkins from models.
This document discusses using the F# programming language for shell scripting. It provides background on shell scripting and functional programming concepts in F#. It then gives examples of F# code for shell scripting, including how to pass command line arguments. Finally, it lists additional resources for learning more about scripting with F#.
This document appears to be notes from a presentation or talk. It discusses various topics related to Plone, a content management system, including its vision, customers as developers, theories of web development, what makes a good development tool, who Plone currently solves problems for, issues with Buildout and the database, minimizing knowledge and steps needed, and developing by default. The document advocates for making Plone more accessible and developable out of the box.
The document discusses high quality iOS development, covering topics like memory management using retain counts, autorelease pools, and ownership rules. It emphasizes avoiding memory leaks and crashes through best practices like analyzing code with Instruments and Clang static analyzer. Crash reports are also discussed as a way to identify and resolve issues in beta testing and released apps.
This document summarizes Jake Smith's presentation on micro-frameworks for PHP given at Dallas PHP on 4/12/2011. It introduces Jake and the topic of micro-frameworks, then provides overviews of several popular PHP micro-frameworks: Minimum, Silex, Limonade, and Slim. For each framework, it lists the website, required PHP version, provides a brief example app, and calls out pros and cons. The goal is to help attendees understand what micro-frameworks are and compare options.
This document discusses different types of extensions for Rails including plugins, gems, and initializers. It notes that gems are now preferred over plugins and provides tips for evaluating the quality of extensions, such as checking activity levels on RubyGems, GitHub, mailing lists, and issue lists. Using gems is often as simple as adding them to the gemfile and running bundle install.
The document discusses how Ruby on Rails (RoR) helped during floods in Australia. It describes how Heroku, a Platform as a Service (PaaS), allows developers to deploy RoR applications using a git-based workflow. Heroku manages web and background processes (dynos and workers) and allows scaling by adding more dynos to handle requests.
The document discusses BoxGrinder, a tool for creating virtual machine appliances from definition files. It describes how appliance definitions work, including general information, hardware requirements, package lists, and mixins. The document also provides an overview of BoxGrinder's build architecture which uses plugins to build appliances from definition files and deliver them to various platforms.
The document discusses different types of software tests and their purposes. It suggests that unit tests should focus on verifying correctness through line and branch coverage and gaining confidence in individual functions. Integration tests are best for experimenting with third-party code but may be a waste of time testing functionality that is not your own. Functional tests work well early in development to verify requirements and key features but may do too much as code changes rapidly.
Introducing the Ceylon Project - Gavin King presentation at QCon Beijing 2011devstonez
The document introduces the Ceylon project, which is designing a new programming language and SDK that addresses frustrations with Java while retaining its successes. The Ceylon project aims to create a language that runs on the JVM, has static typing, automatic memory management, and is readable like Java, but also includes first-class functions, a declarative syntax for defining user interfaces and data, built-in modularity, and addresses issues in the Java SDK. The presentation provides a brief overview of the Ceylon language through a simple "Hello World" example to demonstrate features like annotations, string interpolation, default parameters, and handling nullable values without NullPointerExceptions.
The document introduces the Ceylon project, which aims to design a new programming language and SDK that addresses frustrations with Java while retaining its successes. It was started by Gavin King and his team who have been developing Java frameworks for 10 years. Ceylon will run on the JVM and feature static typing, automatic memory management, and first-class functions while being readable like Java. Gavin provides some examples of Ceylon's syntax including classes, sequences, higher-order functions, and named arguments to demonstrate how it addresses issues in Java. The project is not yet available publicly and this talk is the first public discussion of Ceylon.
2011 JavaOne Apache TomEE Java EE 6 Web ProfileDavid Blevins
Apache TomEE is a Java EE 6 Web Profile certified application server built on top of Tomcat. It includes Apache components like MyFaces, OpenWebBeans, OpenEJB, OpenJPA, and Bean Validation. The entire Web Profile is only 24MB in size and has a small memory footprint. It aims to prove that a certified Java EE stack can be lightweight and agile. Future goals include further optimizations to reduce size and improve performance.
JRuby allows developers to use the Ruby programming language on the Java Virtual Machine. It provides a solid, reliable implementation of Ruby that integrates well with existing Java libraries and tools. JRuby brings the features of Ruby like its elegant syntax to Java developers, while also bringing the large Java ecosystem to Ruby developers. It allows both communities to work together on the same platform.
This document summarizes a presentation about using JRuby in the enterprise. It introduces the speaker and asks the audience about their backgrounds with Ruby, Rails, Java, and JRuby. It then discusses reasons for using JRuby, including better threading support, performance, Java integration, and leveraging existing Java knowledge. It demonstrates Java integration by creating a simple Swing application in Ruby. It also discusses a case study and upcoming features in JRuby 1.4 RC1.
Kendall Clark, CEO of Clark & Parsia, LLC, presented an overview of their new RDF database called Stardog. Key points include that Stardog is fast, lightweight, supports rich APIs, logical and statistical inference, and full-text search. It aims to be the fastest RDF database and supports OWL 2 reasoning and SPARQL queries. Stardog is currently in alpha testing and plans to launch a private beta in early April ahead of its 1.0 release in mid-summer.
The document discusses new features coming to JavaScript in the future. It describes CoffeeScript and compiling ES.next to current JavaScript as ways to experiment with these new features. It lists some approved features for ES.next, including block scope variables, destructuring, default parameters, rest/spread syntax, proxies, weak maps, modules, and iterators/generators. The document also discusses goals for ES.next such as being better for complex apps, libraries, and code generators while keeping versions simple and supporting a secure subset.
The document outlines Shelley Simmons' presentation on project managing interactive projects. The agenda includes introductions, presentations on project management tools and designing projects, workshops on project planning and design, and a guest speaker. Simmons discusses ground rules, key stages of projects including design, testing, revisions and launch. Project elements like goals, user scenarios, flows, research and building a team are also reviewed.
Image and Music: Processing plus Pure Data with libpd libraryPETER KIRN
Make Your Own Free Tools with Processing, Pure Data
Support slides from a talk to CrashSpace, Los Angeles, the debut workshop on using this Pure Data library for Processing
Databases -- Have it Your Way (Frederick Cheung)Skills Matter
If you've used Rails, it's a safe bet to say that you've used Active Record. Active Record isn't the only ruby tool out there for manipulating your database though, and Rails 3 will play nicer than ever with other ORM libraries. Find out the similarities between some of the common ORM libraries, their differences and what makes them tick.
Similar to Building Languages for the JVM - StarTechConf 2011 (20)
A status update on JRuby, covering compatibility, Rails, and next-gen performance numbers. JRuby is currently the fastest way to run Rails apps, and we're doing work to make it even faster in the future.
Down the Rabbit Hole: An Adventure in JVM WonderlandCharles Nutter
The document discusses exploring interesting Java features and how they are compiled and executed by the JVM. It will look at bytecode, compiler logs, and native code generated for simple Java examples. The goal is to understand hidden performance costs, how code design impacts performance, and what the JVM can and cannot optimize. It begins with a "Hello World" example and examines the bytecode, compiler logs showing inlining, and native assembly code generated by the JIT compiler.
JRuby 9000 introduced a new intermediate representation that allows us to use classic compiler strategies to optimize Ruby. This talk describes what we're doing with this new IR and why current JVM capabilities are not sufficient.
JRuby 9000 - Taipei Ruby User's Group 2015Charles Nutter
The document discusses JRuby 9000, a new version of JRuby that runs on a new runtime based on an intermediate representation (IR). Some key points:
- JRuby 9000 includes major performance improvements like just-in-time compiling of blocks and optimized define_method performance.
- The new runtime represents code as IR instructions instead of an AST for better optimization capabilities. It allows registering passes to optimize the IR.
- Future work includes improved inlining, numeric specialization to use primitives on the JVM, and leveraging ahead-of-time compilation capabilities being added to the JVM to improve startup time.
- The overall goal is to continue optimizing JRuby to perform
Fast as C: How to Write Really Terrible JavaCharles Nutter
For years we’ve been told that the JVM’s amazing optimizers can take your running code and make it “fast” or “as fast as C++” or “as fast as C”…or sometimes “faster than C”. And yet we don’t often see this happen in practice, due in large part to (good and bad) development patterns that have taken hold in the Java world.
In this talk, we’ll explore the main reasons why Java code rarely runs as fast as C or C++ and how you can write really bad Java code that the JVM will do a better job of optimizing. We’ll take some popular microbenchmarks and burn them to the ground, monitoring JIT logs and assembly dumps along the way.
Have you ever used an open source project? Of course you have, but have you made any contributions yourself? Filed a bug report? Submitted a patch? Have you ever started your own OSS project, or taken a closed/private project public? What licenses should you use? How do you manage contributions? How do you encourage contributors and get work done? In this talk we'll go over the basics of OSS: how to get involved, how to start a project, how to manage contributions. We'll discuss project lifecycles, legal CYA tips, and how to keep projects moving. You'll see the inner workings of real OSS projects, and learn how to be a better OSS user and producer.
Presented at Jfokus 2015
InvokeBinder: Fluent Programming for Method HandlesCharles Nutter
The MethodHandle API provides a powerful way to build optimized function pointers that do a wide variety of call-path adaptations. Unfortunately, the API as designed requires mental contortions to write anything more than trivial handle chains by hand. Adaptations must be made backwards from the target, argument-list modifications are done by index and length, and debugging failed adaptations can be a terrific challenge. InvokeBinder seeks to make method handles fun and easy to use by providing a fluent API, building adaptations from the call forward, allowing argument-list manipulation by name and wildcard, and much more. We'll explore everything InvokeBinder does today and talk about improvements for the future.
JRuby 9000 represents the biggest-ever leap forward for JRuby. Not only have we caught up on compatibility (9000 will be 2.2-compatible from release), but we've completely redesigned our JVM-based runtime and have opened our codebase up to the JRuby+Truffle research project from Oracle Labs. The changes we've made will make it easier to keep up with MRI on compatibility and give us the potential to run Ruby as fast as Java or C. The entire Ruby world will change over the next year, and JRuby 9000 will be leading the way. We'll talk about what Ruby's going to look like once JRuby is "over 9000".
Have you ever used an open source project? Well of course you have, but how about contributed to one? Filed a bug report? Submitted a patch? Have you ever started your own OSS project, or taken a closed/private project public? What licenses should you use? How do you manage contributions? How do you encourage contributors and get work done? In this talk we'll go over the basics of OSS: how to get involved, how to start a project, how to manage contributions. We'll discuss project lifecycles, legal CYA tips, and how to keep projects moving. You'll see the inner workings of real OSS projects, and learn how to be a better OSS user and producer.
The document discusses challenges in implementing the Ruby programming language on the Java Virtual Machine (JVM) using JRuby. It covers areas like parsing Ruby, implementing different interpreters and compilers, utilizing JVM tricks, ensuring compatibility with features like strings and fibers, and integrating native capabilities. The author also shares decisions they have made around these challenges and future work.
Bringing Concurrency to Ruby - RubyConf India 2014Charles Nutter
The document discusses bringing concurrency to Ruby. It begins by defining concurrency and parallelism, noting that both are needed but platforms only enable parallelism if jobs can split into concurrent tasks. It reviews concurrency and parallelism in popular Ruby platforms like MRI, JRuby, and Rubinius. The document outlines four rules for concurrency and discusses techniques like immutable data, locking, atomics, and specialized collections for mutable data. It highlights libraries that provide high-level concurrency abstractions like Celluloid for actors and Sidekiq for background jobs.
The document discusses strategies for improving the startup performance of JRuby. It describes how the JRuby team optimized startup by using a Java-heavy JDK instead of native code, tweaking JVM flags, and implementing Drip - a technique that pre-boots the JVM and caches runtime configurations between runs. Drip reduced JRuby startup times from over 10 seconds to under 1 second for many common tasks. Later, it discusses challenges with JNI and how the Java Native Runtime (JNR) provides a better alternative for interfacing Java with native code and libraries.
This document provides an overview of upcoming technologies beyond the Java Virtual Machine (JVM). It begins with introductions and then discusses several topics:
- There are many open-source JVMs beyond Oracle's HotSpot such as JamVM, Maxine, and JikesRVM.
- Reasons for using the JVM include its large standard library and ease of portability compared to alternative virtual machines. However, startup time can be slow.
- Techniques for improving JVM startup time are discussed, such as saving JIT-compiled code and using the Drip tool to pre-initialize JVMs.
- Native interoperability is explored through the Java Native Interface (JNI
This document provides an overview of upcoming technologies related to the Java Virtual Machine (JVM). It begins with introductions and goals of the talk. It then discusses what the JVM is and lists many open-source JVMs. Next it explores reasons for and against using the JVM. A timeline of the OpenJDK project is presented. Features of Java 7 and 8 are highlighted. Alternative languages that run on the JVM are listed. Native interoperability via JNI and the Java Native Runtime (JNR) are described. Performance of JNR compared to JNA is shown.
The document discusses exploring interesting Java features and how they are compiled and executed by the Java Virtual Machine (JVM). It begins with an introduction and overview of the topics that will be covered, including looking at Java bytecode, compiler logs, and generated native code. Examples of simple "Hello World" and math programs are provided and their compilation steps are examined at the bytecode, logging and native code levels to demonstrate how Java code is handled by the JVM.
The document discusses JRuby, a Ruby implementation that runs on the Java Virtual Machine. It provides an introduction to JRuby, describing how it allows Ruby code to leverage Java libraries and run on the JVM. It also discusses some of the challenges of implementing Ruby on the JVM, such as performance optimization, and outlines JRuby's approach to addressing issues like concurrency through libraries that provide thread-safe data structures.
The document discusses invokedynamic, a new bytecode introduced in Java 7 that allows for user-definable bytecode behavior. It provides more flexibility compared to the traditional bytecode instructions like invokevirtual. invokedynamic calls a bootstrap method that prepares a CallSite object and MethodHandle to invoke the target method. This allows dynamic dispatch, fast method pointers, and optimizable behavior like normal Java code. The document includes examples of using invokedynamic to implement dynamic language features and define new domain-specific languages.
Taking AI to the Next Level in Manufacturing.pdfssuserfac0301
Read Taking AI to the Next Level in Manufacturing to gain insights on AI adoption in the manufacturing industry, such as:
1. How quickly AI is being implemented in manufacturing.
2. Which barriers stand in the way of AI adoption.
3. How data quality and governance form the backbone of AI.
4. Organizational processes and structures that may inhibit effective AI adoption.
6. Ideas and approaches to help build your organization's AI strategy.
How to Interpret Trends in the Kalyan Rajdhani Mix Chart.pdfChart Kalyan
A Mix Chart displays historical data of numbers in a graphical or tabular form. The Kalyan Rajdhani Mix Chart specifically shows the results of a sequence of numbers over different periods.
Salesforce Integration for Bonterra Impact Management (fka Social Solutions A...Jeffrey Haguewood
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on integration of Salesforce with Bonterra Impact Management.
Interested in deploying an integration with Salesforce for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
A Comprehensive Guide to DeFi Development Services in 2024Intelisync
DeFi represents a paradigm shift in the financial industry. Instead of relying on traditional, centralized institutions like banks, DeFi leverages blockchain technology to create a decentralized network of financial services. This means that financial transactions can occur directly between parties, without intermediaries, using smart contracts on platforms like Ethereum.
In 2024, we are witnessing an explosion of new DeFi projects and protocols, each pushing the boundaries of what’s possible in finance.
In summary, DeFi in 2024 is not just a trend; it’s a revolution that democratizes finance, enhances security and transparency, and fosters continuous innovation. As we proceed through this presentation, we'll explore the various components and services of DeFi in detail, shedding light on how they are transforming the financial landscape.
At Intelisync, we specialize in providing comprehensive DeFi development services tailored to meet the unique needs of our clients. From smart contract development to dApp creation and security audits, we ensure that your DeFi project is built with innovation, security, and scalability in mind. Trust Intelisync to guide you through the intricate landscape of decentralized finance and unlock the full potential of blockchain technology.
Ready to take your DeFi project to the next level? Partner with Intelisync for expert DeFi development services today!
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/temporal-event-neural-networks-a-more-efficient-alternative-to-the-transformer-a-presentation-from-brainchip/
Chris Jones, Director of Product Management at BrainChip , presents the “Temporal Event Neural Networks: A More Efficient Alternative to the Transformer” tutorial at the May 2024 Embedded Vision Summit.
The expansion of AI services necessitates enhanced computational capabilities on edge devices. Temporal Event Neural Networks (TENNs), developed by BrainChip, represent a novel and highly efficient state-space network. TENNs demonstrate exceptional proficiency in handling multi-dimensional streaming data, facilitating advancements in object detection, action recognition, speech enhancement and language model/sequence generation. Through the utilization of polynomial-based continuous convolutions, TENNs streamline models, expedite training processes and significantly diminish memory requirements, achieving notable reductions of up to 50x in parameters and 5,000x in energy consumption compared to prevailing methodologies like transformers.
Integration with BrainChip’s Akida neuromorphic hardware IP further enhances TENNs’ capabilities, enabling the realization of highly capable, portable and passively cooled edge devices. This presentation delves into the technical innovations underlying TENNs, presents real-world benchmarks, and elucidates how this cutting-edge approach is positioned to revolutionize edge AI across diverse applications.
Building Production Ready Search Pipelines with Spark and MilvusZilliz
Spark is the widely used ETL tool for processing, indexing and ingesting data to serving stack for search. Milvus is the production-ready open-source vector database. In this talk we will show how to use Spark to process unstructured data to extract vector representations, and push the vectors to Milvus vector database for search serving.
Dandelion Hashtable: beyond billion requests per second on a commodity serverAntonios Katsarakis
This slide deck presents DLHT, a concurrent in-memory hashtable. Despite efforts to optimize hashtables, that go as far as sacrificing core functionality, state-of-the-art designs still incur multiple memory accesses per request and block request processing in three cases. First, most hashtables block while waiting for data to be retrieved from memory. Second, open-addressing designs, which represent the current state-of-the-art, either cannot free index slots on deletes or must block all requests to do so. Third, index resizes block every request until all objects are copied to the new index. Defying folklore wisdom, DLHT forgoes open-addressing and adopts a fully-featured and memory-aware closed-addressing design based on bounded cache-line-chaining. This design offers lock-free index operations and deletes that free slots instantly, (2) completes most requests with a single memory access, (3) utilizes software prefetching to hide memory latencies, and (4) employs a novel non-blocking and parallel resizing. In a commodity server and a memory-resident workload, DLHT surpasses 1.6B requests per second and provides 3.5x (12x) the throughput of the state-of-the-art closed-addressing (open-addressing) resizable hashtable on Gets (Deletes).
Trusted Execution Environment for Decentralized Process MiningLucaBarbaro3
Presentation of the paper "Trusted Execution Environment for Decentralized Process Mining" given during the CAiSE 2024 Conference in Cyprus on June 7, 2024.
Fueling AI with Great Data with Airbyte WebinarZilliz
This talk will focus on how to collect data from a variety of sources, leveraging this data for RAG and other GenAI use cases, and finally charting your course to productionalization.
HCL Notes and Domino License Cost Reduction in the World of DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-and-domino-license-cost-reduction-in-the-world-of-dlau/
The introduction of DLAU and the CCB & CCX licensing model caused quite a stir in the HCL community. As a Notes and Domino customer, you may have faced challenges with unexpected user counts and license costs. You probably have questions on how this new licensing approach works and how to benefit from it. Most importantly, you likely have budget constraints and want to save money where possible. Don’t worry, we can help with all of this!
We’ll show you how to fix common misconfigurations that cause higher-than-expected user counts, and how to identify accounts which you can deactivate to save money. There are also frequent patterns that can cause unnecessary cost, like using a person document instead of a mail-in for shared mailboxes. We’ll provide examples and solutions for those as well. And naturally we’ll explain the new licensing model.
Join HCL Ambassador Marc Thomas in this webinar with a special guest appearance from Franz Walder. It will give you the tools and know-how to stay on top of what is going on with Domino licensing. You will be able lower your cost through an optimized configuration and keep it low going forward.
These topics will be covered
- Reducing license cost by finding and fixing misconfigurations and superfluous accounts
- How do CCB and CCX licenses really work?
- Understanding the DLAU tool and how to best utilize it
- Tips for common problem areas, like team mailboxes, functional/test users, etc
- Practical examples and best practices to implement right away
This presentation provides valuable insights into effective cost-saving techniques on AWS. Learn how to optimize your AWS resources by rightsizing, increasing elasticity, picking the right storage class, and choosing the best pricing model. Additionally, discover essential governance mechanisms to ensure continuous cost efficiency. Whether you are new to AWS or an experienced user, this presentation provides clear and practical tips to help you reduce your cloud costs and get the most out of your budget.
Generating privacy-protected synthetic data using Secludy and MilvusZilliz
During this demo, the founders of Secludy will demonstrate how their system utilizes Milvus to store and manipulate embeddings for generating privacy-protected synthetic data. Their approach not only maintains the confidentiality of the original data but also enhances the utility and scalability of LLMs under privacy constraints. Attendees, including machine learning engineers, data scientists, and data managers, will witness first-hand how Secludy's integration with Milvus empowers organizations to harness the power of LLMs securely and efficiently.
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.
Building Languages for the JVM - StarTechConf 2011
1. Building Languages
for the JVM
Charles Oliver Nutter
Friday, November 4, 2011
2. Me
• Charles Oliver Nutter
• JRuby and JVM guy
• “headius” on most services
• headius@headius.com
Friday, November 4, 2011
3. Who Was I?
• Java EE architect
• Successfully!
• Never wrote a parser
• Never wrote a compiler
• But I wanted to learn how...
Friday, November 4, 2011
4. You
• Java?
• Ruby?
• Python?
• C#?
• Other?
Friday, November 4, 2011
5. Why Create Languages?
• Nothing is perfect
• New problems need new solutions
• Language design can be fun
• Fame and fortune?
• Not really.
Friday, November 4, 2011
6. Why Impl a Language?
• To learn it?
• Sort of...
• To learn the target platform
• Definitely!
• Fame and fortune?
• Well...getting there...
Friday, November 4, 2011
7. Challenges
• Community
• Platform
• Specifications
• Resources
Friday, November 4, 2011
8. Community
• Investment in status quo
• Afraid to stand out
• Known quantities
• Everything else sucks
• Gotta get paid!
Friday, November 4, 2011
9. Platform
• Matching language semantics
• JVM designed around Java
• JVM hides underlying platform
• Challenging to use
• Not bad...C/++ would be way worse
• Community may hate it ;-)
Friday, November 4, 2011
10. Specifications
• Incomplete
• Ruby had none for years
• ...and no complete test suites
• Difficult to implement
• Low level features
• Single-implementation quirks
• Hard or impossible to optimize
Friday, November 4, 2011
11. Resources
• You gotta eat
• Not much money in language work
• Some parts are hard
• OSS is a necessity
Friday, November 4, 2011
12. Why JVM?
• Because I am lazy
• Because VMs are *hard*
• Because I can’t be awesome at everything
Friday, November 4, 2011
21. Ruby on the JVM
• All of Ruby’s power and beauty
• Solid VM underneath
• “Just another JVM language”
Friday, November 4, 2011
22. JVM Language
• Full interop with Java
• Tricky to do...
• Very rewarding for 99% case
• VM concerns solved
• No need to write a GC
• No need to write a JIT
• ...oh, but wait...
Friday, November 4, 2011
23. More than a JVM
language
• Use native code where JDK fails us
• Paper over ugly bits like CLASSPATH
• Matching Ruby semantics exactly*
• Push JVM forward too!
Friday, November 4, 2011
24. Playing with JRuby
• Simple IRB demo
• JRuby on Rails - see Jano’s talk tomorrow
• JRuby performance
• PotC (???)
Friday, November 4, 2011
27. Parser
• Port of MRI’s Bison grammar
• “Jay” parser generator for Java
• Hand-written lexer
• Nearly as fast as the C version
• ...once it gets going
Friday, November 4, 2011
28. system ~/projects/jruby $ jruby -y -e "1 + 1"
push state 0 value null
reduce tate 0 uncover 0
s rule (1) $$1 :
goto from state 0 to 2
push state 2 value null
lex tate 2 reading tIDENTIFIER value Token { Value=load,
s
Position=file:/Users/headius/projects/jruby/lib/jruby.jar!/
jruby/kernel.rb:6}
shift from state 2 to 33
push state 33 value Token { Value=load, Position=file:/Users/
headius/projects/jruby/lib/jruby.jar!/jruby/kernel.rb:6}
lex tate 33 reading tSTRING_BEG value Token { Value=',
s
Position=file:/Users/headius/projects/jruby/lib/jruby.jar!/
jruby/kernel.rb:6}
reduce tate 33 uncover 2
s rule (487) operation : tIDENTIFIER
goto from state 2 to 62
push state 62 value Token { Value=load, Position=file:/Users/
headius/projects/jruby/lib/jruby.jar!/jruby/kernel.rb:6}
reduce tate 62 uncover 62 rule (252) $$6 :
s
Friday, November 4, 2011
29. system ~/projects/jruby $ jruby -y -e "1 + 1"
push state 0 value null
reduce tate 0 uncover 0
s rule (1) $$1 :
goto from state 0 to 2
push state 2 value null
lex tate 2 reading tIDENTIFIER value Token { Value=load,
s
Position=file:/Users/headius/projects/jruby/lib/jruby.jar!/
jruby/kernel.rb:6}
shift from state 2 to 33
You will never need this.
push state 33 value Token { Value=load, Position=file:/Users/
headius/projects/jruby/lib/jruby.jar!/jruby/kernel.rb:6}
lex tate 33 reading tSTRING_BEG value Token { Value=',
s
Position=file:/Users/headius/projects/jruby/lib/jruby.jar!/
jruby/kernel.rb:6}
reduce tate 33 uncover 2
s rule (487) operation : tIDENTIFIER
goto from state 2 to 62
push state 62 value Token { Value=load, Position=file:/Users/
headius/projects/jruby/lib/jruby.jar!/jruby/kernel.rb:6}
reduce tate 62 uncover 62 rule (252) $$6 :
s
Friday, November 4, 2011
30. public class RubyYaccLexer {
public static final Encoding UTF8_ENCODING = UTF8Encoding.INSTANCE;
public static final Encoding USASCII_ENCODING = USASCIIEncoding.INSTANCE;
public static final Encoding ASCII8BIT_ENCODING = ASCIIEncoding.INSTANCE;
private static ByteList END_MARKER = new ByteList(new byte[] {'_', 'E', 'N', 'D', '_', '_'});
private static ByteList BEGIN_DOC_MARKER = new ByteList(new byte[] {'b', 'e', 'g', 'i', 'n'});
private static ByteList END_DOC_MARKER = new ByteList(new byte[] {'e', 'n', 'd'});
private static final HashMap<String, Keyword> map;
static {
map = new HashMap<String, Keyword>();
map.put("end", Keyword.END);
map.put("else", Keyword.ELSE);
map.put("case", Keyword.CASE);
map.put("ensure", Keyword.ENSURE);
map.put("module", Keyword.MODULE);
map.put("elsif", Keyword.ELSIF);
map.put("def", Keyword.DEF);
map.put("rescue", Keyword.RESCUE);
map.put("not", Keyword.NOT);
map.put("then", Keyword.THEN);
map.put("yield", Keyword.YIELD);
map.put("for", Keyword.FOR);
map.put("self", Keyword.SELF);
map.put("false", Keyword.FALSE);
Friday, November 4, 2011
32. private int yylex() throws IOException {
int c;
boolean spaceSeen = false;
boolean commandState;
if (lex_strterm != null) {
int tok = lex_strterm.parseString(this, src);
if (tok == Tokens.tSTRING_END || tok == Tokens.tREGEXP_END) {
lex_strterm = null;
setState(LexState.EXPR_END);
}
return tok;
}
commandState = commandStart;
commandStart = false;
loop: for(;;) {
c = src.read();
switch(c) {
Friday, November 4, 2011
33. case '<':
return lessThan(spaceSeen);
case '>':
return greaterThan();
case '"':
return doubleQuote();
case '`':
return backtick(commandState);
case ''':
return singleQuote();
case '?':
return questionMark();
case '&':
return ampersand(spaceSeen);
case '|':
return pipe();
case '+':
return plus(spaceSeen);
Friday, November 4, 2011
34. private int lessThan(boolean spaceSeen) throws IOException {
int c = src.read();
if (c == '<' && lex_state != LexState.EXPR_DOT && lex_state !=
LexState.EXPR_CLASS &&
!isEND() && (!isARG() || spaceSeen)) {
int tok = hereDocumentIdentifier();
if (tok != 0) return tok;
}
determineExpressionState();
switch (c) {
case '=':
if ((c = src.read()) == '>') {
yaccValue = new Token("<=>", getPosition());
return Tokens.tCMP;
Friday, November 4, 2011
35. %%
program : {
lexer.setState(LexState.EXPR_BEG);
support.initTopLocalVariables();
} top_compstmt {
// ENEBO: Removed !compile_for_eval which probably is to reduce
warnings
if ($2 != null) {
/* last expression should not be void */
if ($2 instanceof BlockNode) {
support.checkUselessStatement
($<BlockNode>2.getLast());
} else {
support.checkUselessStatement($2);
}
}
support.getResult().setAST(support.addRootNode
($2, support.getPosition($2)));
}
Friday, November 4, 2011
36. stmt : kALIAS fitem {
lexer.setState(LexState.EXPR_FNAME);
} fitem {
$$ = support.newAlias($1.getPosition(), $2, $4);
}
| kALIAS tGVAR tGVAR {
$$ = new VAliasNode($1.getPosition(), (String)
$2.getValue(), (String) $3.getValue());
}
| kALIAS tGVAR tBACK_REF {
$$ = new VAliasNode($1.getPosition(), (String)
$2.getValue(), "$" + $<BackRefNode>3.getType());
}
| kALIAS tGVAR tNTH_REF {
support.yyerror("can't make alias for the number
variables");
}
| kUNDEF undef_list {
$$ = $2;
}
| stmt kIF_MOD expr_value {
$$ = new IfNode(support.getPosition($1),
support.getConditionNode($3), $1, null);
}
Friday, November 4, 2011
37. public Object yyparse (RubyYaccLexer yyLex) throws java.io.IOException {
if (yyMax <= 0) yyMax = 256;"" " // initial size
int yyState = 0, yyStates[] = new int[yyMax];" // state stack
Object yyVal = null, yyVals[] = new Object[yyMax];" // value stack
int yyToken = -1;" " " " " // current input
int yyErrorFlag = 0;" " " " // #tokens to shift
yyLoop: for (int yyTop = 0;; ++ yyTop) {
if (yyTop >= yyStates.length) {" " " // dynamically increase
int[] i = new int[yyStates.length+yyMax];
System.arraycopy(yyStates, 0, i, 0, yyStates.length);
yyStates = i;
Object[] o = new Object[yyVals.length+yyMax];
System.arraycopy(yyVals, 0, o, 0, yyVals.length);
yyVals = o;
}
yyStates[yyTop] = yyState;
yyVals[yyTop] = yyVal;
if (yydebug != null) yydebug.push(yyState, yyVal);
Friday, November 4, 2011
59. public class ASTCompiler {
private boolean isAtRoot = true;
public void compileBody(Node node, BodyCompiler context, boolean expr) {
Node oldBodyNode = currentBodyNode;
currentBodyNode = node;
compile(node, context, expr);
currentBodyNode = oldBodyNode;
}
public void compile(Node node, BodyCompiler context, boolean expr) {
if (node == null) {
if (expr) context.loadNil();
return;
}
switch (node.getNodeType()) {
case ALIASNODE:
compileAlias((AliasNode) node, context, expr);
break;
case ANDNODE:
compileAnd(node, context, expr);
break;
Friday, November 4, 2011
60. public void compileIf(Node node, BodyCompiler context, final boolean expr) {
final IfNode ifNode = (IfNode) node;
// optimizations if we know ahead of time it will always be true or false
Node actualCondition = ifNode.getCondition();
while (actualCondition instanceof NewlineNode) {
actualCondition = ((NewlineNode)actualCondition).getNextNode();
}
if (actualCondition.getNodeType().alwaysTrue()) {
// compile condition as non-expr and just compile "then" body
compile(actualCondition, context, false);
compile(ifNode.getThenBody(), context, expr);
} else if (actualCondition.getNodeType().alwaysFalse()) {
// always false or nil
compile(ifNode.getElseBody(), context, expr);
} else {
Friday, November 4, 2011
61. BranchCallback trueCallback = new BranchCallback() {
public void branch(BodyCompiler context) {
if (ifNode.getThenBody() != null) {
compile(ifNode.getThenBody(), context, expr);
} else {
if (expr) context.loadNil();
}
}
};
BranchCallback falseCallback = new BranchCallback() {
public void branch(BodyCompiler context) {
if (ifNode.getElseBody() != null) {
compile(ifNode.getElseBody(), context, expr);
} else {
if (expr) context.loadNil();
}
}
};
// normal
compile(actualCondition, context, true);
context.performBooleanBranch(trueCallback, falseCallback);
}
Friday, November 4, 2011
62. public abstract class BaseBodyCompiler implements BodyCompiler {
protected SkinnyMethodAdapter method;
protected VariableCompiler variableCompiler;
protected InvocationCompiler invocationCompiler;
protected int argParamCount;
protected Label[] currentLoopLabels;
protected Label scopeStart = new Label();
protected Label scopeEnd = new Label();
protected Label redoJump;
protected boolean inNestedMethod = false;
private int lastLine = -1;
private int lastPositionLine = -1;
protected StaticScope scope;
protected ASTInspector inspector;
protected String methodName;
protected String rubyName;
protected StandardASMCompiler script;
Friday, November 4, 2011
63. public void performBooleanBranch(BranchCallback trueBranch,
BranchCallback falseBranch) {
Label afterJmp = new Label();
Label falseJmp = new Label();
// call isTrue on the result
isTrue();
method.ifeq(falseJmp); // EQ == 0 (i.e. false)
trueBranch.branch(this);
method.go_to(afterJmp);
// FIXME: optimize for cases where we have no false branch
method.label(falseJmp);
falseBranch.branch(this);
method.label(afterJmp);
}
Friday, November 4, 2011