The document discusses the Merb 2.0 framework. It covers core Merb principles like performance and concurrency. It shows how to build Rack-based applications in Merb and ensure they are thread-safe. Modularity is achieved through managing dependencies with specific gem versions. Charts show Merb's concurrency on different Ruby implementations and web servers.
Luis Majano introduces CBT, a templating engine for ColdBox applications based on Twig. CBT allows separating presentation logic from application code through reusable templates. Templates have access to data through a rendering context and support common constructs like variables, tags, filters, inheritance and more. CBT aims to empower non-developers to edit templates while restricting programming capabilities and automatically preventing XSS attacks.
Matteo Collina | Take your HTTP server to Ludicrous Speed | Codmeotion Madrid...Codemotion
In my journey through nodeland, I always wonder about the cost of my abstractions. Express, Hapi, Restify, or just plain Node.js core? require(‘http’) can reach 30k requests/sec, Express 22k, and Hapi 21k. I started a journey to write an HTTP framework with extremely low overhead, and Fastify was born. With its ability to reach an astonishing 37k requests/sec, Fastify can halve your cloud server bill. How can Fastify be so.. fast? We will discover all the not-so-secret techniques that were used to optimize it. In Fastify we reach a point where even allocating a callback is too slow: Ludicrous
How and why I turned my old Java projects into a first-class serverless compo...Mario Fusco
Mario Fusco discusses turning old Java rule engine projects into serverless components by refactoring them to run natively on GraalVM and integrate with Quarkus. He describes the limitations of ahead-of-time compilation with GraalVM, such as lack of dynamic classloading. He details refactoring Drools to use an executable model and removing dependencies on dynamic class definition. This allows Drools to natively compile on GraalVM. He also discusses integrating the refactored Drools with Quarkus.
JEEConf 2017 - How to find deadlock not getting into itNikita Koval
Deadlocks are one of the main problems in multithreaded programming. This talk presents Dl-Check – a novel tool for detecting potential deadlocks at runtime of Java programs. In order to implement this tool, the bytecode instrumentation is required as well as the ASM framework is advantageous.
In the first part of the talk, the general approach and the algorithm for online detection of potential deadlocks will be presented. As for the second part, byte-code instrumentation and several useful techniques and associated cases related to it will be discussed.
Comparing different concurrency models on the JVMMario Fusco
This document compares different concurrency models on the JVM, including the native Java concurrency model based on threads, semaphores, and locks. It discusses the pros and cons of threads and locks, including issues around non-determinism from shared mutable state. Functional programming with immutable data and internal iteration is presented as an alternative that allows for free parallelism. The document also covers actors and their message passing approach, as well as software transactional memory.
The document provides an introduction and overview of the Ruby on Rails framework presented by Fabio Akita. It covers topics such as Ruby and Rails installation on different platforms like Mac, Linux, and Windows. It also discusses tools used with Rails like version control systems, databases, image processing libraries. The document presents conventions in Ruby code as well as common programming structures. It emphasizes that everything in Ruby is an object and all computation is performed by sending messages.
Java9 Beyond Modularity - Java 9 más allá de la modularidadDavid Gómez García
These are the slides I used for my "Java 9 beyond modularity" at several different local meetups and conferences in Spain during 2017
Java 9 is about to reach its public release scheduled for September 2017. If we ask what are the new features that this new version will include, probably the first that comes to our head is modularity.
But java 9 brings with a lot of features beyound Jigsaw, JPMS or modularity. In this talk we will talk about at least 9 other new features that include this new version of Java that are interesting and maybe will end up being more used than the modularity itself for those who embrace the new version.
Those are changes that come to complement and improve even more the set of new tools (like Streams, Optionals, etc...) that Java 8 brought to us.
We'll take a look at small changes in language syntax (such as new ways of using try-with-resources), changes in Collections APIs and Streams, new tools like VarHandles, new APIs such as the Flow API, and As we allow the inclusion of reactive programming with Java.
Do you want to see in Java 9 beyond modularity? Do you want to have a more complete view of what you can provide? Let's take a look toghether!
Ten useful JavaScript tips & best practicesAnkit Rastogi
In this presentation there are ten useful JavaScript techniques which can be included in your application easily with less friction along with some AngularJs tips and best practices as a bonus. These tips and best practices are accompanied by examples & will cover script loading, design pattern, performance optimization and other areas.
Since best practices are very subjective topics, proper benchmarking needs to be done.
Luis Majano introduces CBT, a templating engine for ColdBox applications based on Twig. CBT allows separating presentation logic from application code through reusable templates. Templates have access to data through a rendering context and support common constructs like variables, tags, filters, inheritance and more. CBT aims to empower non-developers to edit templates while restricting programming capabilities and automatically preventing XSS attacks.
Matteo Collina | Take your HTTP server to Ludicrous Speed | Codmeotion Madrid...Codemotion
In my journey through nodeland, I always wonder about the cost of my abstractions. Express, Hapi, Restify, or just plain Node.js core? require(‘http’) can reach 30k requests/sec, Express 22k, and Hapi 21k. I started a journey to write an HTTP framework with extremely low overhead, and Fastify was born. With its ability to reach an astonishing 37k requests/sec, Fastify can halve your cloud server bill. How can Fastify be so.. fast? We will discover all the not-so-secret techniques that were used to optimize it. In Fastify we reach a point where even allocating a callback is too slow: Ludicrous
How and why I turned my old Java projects into a first-class serverless compo...Mario Fusco
Mario Fusco discusses turning old Java rule engine projects into serverless components by refactoring them to run natively on GraalVM and integrate with Quarkus. He describes the limitations of ahead-of-time compilation with GraalVM, such as lack of dynamic classloading. He details refactoring Drools to use an executable model and removing dependencies on dynamic class definition. This allows Drools to natively compile on GraalVM. He also discusses integrating the refactored Drools with Quarkus.
JEEConf 2017 - How to find deadlock not getting into itNikita Koval
Deadlocks are one of the main problems in multithreaded programming. This talk presents Dl-Check – a novel tool for detecting potential deadlocks at runtime of Java programs. In order to implement this tool, the bytecode instrumentation is required as well as the ASM framework is advantageous.
In the first part of the talk, the general approach and the algorithm for online detection of potential deadlocks will be presented. As for the second part, byte-code instrumentation and several useful techniques and associated cases related to it will be discussed.
Comparing different concurrency models on the JVMMario Fusco
This document compares different concurrency models on the JVM, including the native Java concurrency model based on threads, semaphores, and locks. It discusses the pros and cons of threads and locks, including issues around non-determinism from shared mutable state. Functional programming with immutable data and internal iteration is presented as an alternative that allows for free parallelism. The document also covers actors and their message passing approach, as well as software transactional memory.
The document provides an introduction and overview of the Ruby on Rails framework presented by Fabio Akita. It covers topics such as Ruby and Rails installation on different platforms like Mac, Linux, and Windows. It also discusses tools used with Rails like version control systems, databases, image processing libraries. The document presents conventions in Ruby code as well as common programming structures. It emphasizes that everything in Ruby is an object and all computation is performed by sending messages.
Java9 Beyond Modularity - Java 9 más allá de la modularidadDavid Gómez García
These are the slides I used for my "Java 9 beyond modularity" at several different local meetups and conferences in Spain during 2017
Java 9 is about to reach its public release scheduled for September 2017. If we ask what are the new features that this new version will include, probably the first that comes to our head is modularity.
But java 9 brings with a lot of features beyound Jigsaw, JPMS or modularity. In this talk we will talk about at least 9 other new features that include this new version of Java that are interesting and maybe will end up being more used than the modularity itself for those who embrace the new version.
Those are changes that come to complement and improve even more the set of new tools (like Streams, Optionals, etc...) that Java 8 brought to us.
We'll take a look at small changes in language syntax (such as new ways of using try-with-resources), changes in Collections APIs and Streams, new tools like VarHandles, new APIs such as the Flow API, and As we allow the inclusion of reactive programming with Java.
Do you want to see in Java 9 beyond modularity? Do you want to have a more complete view of what you can provide? Let's take a look toghether!
Ten useful JavaScript tips & best practicesAnkit Rastogi
In this presentation there are ten useful JavaScript techniques which can be included in your application easily with less friction along with some AngularJs tips and best practices as a bonus. These tips and best practices are accompanied by examples & will cover script loading, design pattern, performance optimization and other areas.
Since best practices are very subjective topics, proper benchmarking needs to be done.
The Road To Reactive with RxJava JEEConf 2016Frank Lyaruu
This document introduces Reactive Programming with RxJava and how it can be used to create non-blocking applications. It discusses the limitations of blocking code and how RxJava uses Observables and Subscribers to implement reactive and asynchronous operations. It provides examples of converting blocking servlets and HTTP calls to non-blocking using RxJava. While non-blocking code is not always faster, it allows asynchronous operations to utilize threads more efficiently.
This document provides an overview of basic JavaScript concepts including variables, functions, conditional statements, loops and recursion. It includes code examples and assignments for each concept. The assignments demonstrate core JavaScript syntax and increase in complexity, covering if/else statements, switch cases, while/do-while/for loops, and recursive functions for calculating factorials and Fibonacci series. Later assignments involve more complex tasks like printing multiple patterns and combining different statements. The document serves as a learning guide for JavaScript fundamentals.
Non-blocking synchronization — what is it and why we (don't?) need itAlexey Fyodorov
This document contains notes from a presentation on non-blocking synchronization. It introduces concepts like concurrency, locking, compare-and-swap (CAS) operations, and how they are implemented in Java using classes like AtomicLong. CAS allows updating shared memory without locking, but can involve retries if the expected value changes. Java provides various atomic data structures like scalars, arrays, and accumulators that have lock-free or obstruction-free guarantees. Non-blocking data structures like lock-free stacks and queues are also discussed.
The document discusses several programming languages and libraries that provide concurrency constructs for parallel programming. It describes features for concurrency in Ada 95, Java, and C/C++ libraries including pthreads. Key features covered include threads, mutual exclusion locks, condition variables, and examples of implementing a bounded buffer for inter-thread communication.
Lenses and Prisms in Swift - Elviro Rocca - Codemotion Rome 2018 Codemotion
The concept of functional Lens has become pretty popular in functional programming circles, and there are already good contributions for applying lenses to other, traditionally imperative/OO contexts. I’d like to offer a more in depth view on why lenses can be useful in Swift, and also talk about an associated concept called Prism. Let’s consider some practical problems and confront an idiomatic/imperative approach to the one based on lenses and prisms.
The document discusses various micro-optimizations that can be made in Java code to improve performance, including:
1. Avoiding boxing/unboxing of primitives, using primitive types instead of object wrappers when possible.
2. Using custom parsing methods instead of built-in String/regex methods like split(), trim(), equals() which have higher overhead.
3. Reducing object allocations by reusing objects/arrays when possible, avoiding unnecessary object creations, and using primitive arrays over object arrays.
4. Leveraging intrinsic methods, avoiding interpretation overhead through direct calls, and bypassing virtual method calls when the implementation is known.
This document discusses the use of deterministic simulation to test distributed systems. It describes how Flow, a programming language extension to C++, can be used to simulate concurrency and external communications deterministically. This allows debugging a simulation instead of the live distributed system. Key aspects of the simulation include single-threaded pseudo-concurrency, simulating external connections and files, and ensuring all control flow is deterministic based only on inputs. The simulator is used to run tests and simulated disasters to uncover bugs in a more efficient manner than real world testing alone.
This document provides an overview of writing clean code, focusing on readability, code style, naming conventions, code comments, control structures, functions/methods, classes, and modules. Key points include formatting code for readability, using explicit and descriptive naming, minimizing comments by ensuring code is self-explanatory, limiting nested control structures and side effects, following single responsibility and encapsulation principles, and leveraging software patterns.
The document provides an overview of new features in WebSphere Message Broker v6.x compared to earlier versions. Some key highlights include:
- Support for configuration without a database and on multiple platforms beyond just Windows.
- Enhanced Java Compute Nodes that allow using third party Java libraries for transformations, routing, filtering, and other tasks.
- New security features like identity extraction and authentication from messages.
- Extended use of XPath for node configuration and accessing message contents from Java code.
JS Fest 2019. Thomas Watson. Post-Mortem Debugging in Node.jsJSFestUA
Post-Mortem debugging is a really powerful technique that allows you, through the use of several tools, to take a memory dump when an issue occurs in your application and later analyze it offline.
The talk will primarily focus on llnode and how you can use this tool to better understand why a Node.js process is behaving odd or is crashing.
The document discusses various primitive data types including numeric, boolean, character, and string types. It describes integers, floating point numbers, complex numbers, decimals, booleans, characters, and strings. It also covers array types like static, dynamic, and associative arrays. Other topics include records, slices, and unions.
The document discusses various primitive data types including numeric, boolean, character, and string types. It describes integer types like byte, short, int that can store negative numbers using two's complement. Floating point types are represented as fractions and exponents. Boolean types are either true or false. Character types are stored as numeric codes. String types can have static, limited dynamic, or fully dynamic lengths. User-defined types like enumerations and subranges are also covered. The document also discusses array types including their initialization, operations, and implementation using row-major and column-major ordering. Associative arrays are described as unordered collections indexed by keys. Record and union types are summarized.
This document discusses transactions in Grails, including what transactions are, how to use transactions in Grails services through the @Transactional annotation, transaction isolation levels, propagation types, unintentionally bypassing the bean proxy, Spring classes for working with transactions, and two-phase commit for multiple databases. Key points covered include using the @Transactional annotation on Grails services, the various configuration options for @Transactional like isolation and propagation, and Spring utility classes like TransactionSynchronizationManager and TransactionAspectSupport.
The document provides templates and examples for creating Swing-based GUI applications, servlets, Java Server Pages (JSP), Java Database Connectivity (JDBC), Java Server Faces (JSF), Enterprise Java Beans (EJB), Hibernate, Struts, and web services in Java. It includes templates for common GUI components, servlets, JSP tags, database queries, managed beans, navigation rules, entity beans, Hibernate mappings, actions, and web service providers/consumers.
Good and Bad Code
The Broken Window Theory
The Grand Redesign in the Sky
The Sushi Chef Rule
The Hotel Room Rule
The Boy Scout Rule
OOP Patterns and Principles
SOLID Principles
How to measure clean code?
Tools
The document discusses the scripting capabilities of Groovy and how it simplifies scripting compared to Java. Groovy allows separating code into simple scripts without unnecessary class and method definitions. It supports various approaches for running scripts, including via a GroovyShell, GroovyScriptEngine, or by implementing the JSR-223 scripting API. Groovy also allows predefining variables and methods in a script's binding to make domain-specific languages more natural to use.
This document discusses the good parts of Javascript. It argues that while Javascript has some design mistakes and inconsistencies due to its rushed creation, it is a powerful and misunderstood language. The document highlights some of Javascript's good features, including functions as first-class objects, closures, objects and prototypal inheritance, and arrays. It advocates focusing on Javascript's strengths rather than its weaknesses.
The document discusses different approaches to handling JavaScript and AJAX functionality in Rails applications. It begins by showing how to use Rails' remote_form_for helper to generate JavaScript and AJAX code inline. It then demonstrates how to handle AJAX requests by binding JavaScript directly. The document also explores using JSON to return data from the server and the RJS format for generating JavaScript responses. Overall it provides examples of incrementally moving away from Rails' default JavaScript handling towards binding JavaScript directly.
The document discusses the evolution of the Rails framework from version 3 to the present. It describes how Rails 3 transitioned from being vaporware to becoming fully featured and stable. It provides examples of how ActiveSupport and ActionController were modularized with clear dependencies between components like ActionDispatch, AbstractController, and ActionController. The document also shows the organization of files within different Rails components and how rendering works in ActionController.
The Road To Reactive with RxJava JEEConf 2016Frank Lyaruu
This document introduces Reactive Programming with RxJava and how it can be used to create non-blocking applications. It discusses the limitations of blocking code and how RxJava uses Observables and Subscribers to implement reactive and asynchronous operations. It provides examples of converting blocking servlets and HTTP calls to non-blocking using RxJava. While non-blocking code is not always faster, it allows asynchronous operations to utilize threads more efficiently.
This document provides an overview of basic JavaScript concepts including variables, functions, conditional statements, loops and recursion. It includes code examples and assignments for each concept. The assignments demonstrate core JavaScript syntax and increase in complexity, covering if/else statements, switch cases, while/do-while/for loops, and recursive functions for calculating factorials and Fibonacci series. Later assignments involve more complex tasks like printing multiple patterns and combining different statements. The document serves as a learning guide for JavaScript fundamentals.
Non-blocking synchronization — what is it and why we (don't?) need itAlexey Fyodorov
This document contains notes from a presentation on non-blocking synchronization. It introduces concepts like concurrency, locking, compare-and-swap (CAS) operations, and how they are implemented in Java using classes like AtomicLong. CAS allows updating shared memory without locking, but can involve retries if the expected value changes. Java provides various atomic data structures like scalars, arrays, and accumulators that have lock-free or obstruction-free guarantees. Non-blocking data structures like lock-free stacks and queues are also discussed.
The document discusses several programming languages and libraries that provide concurrency constructs for parallel programming. It describes features for concurrency in Ada 95, Java, and C/C++ libraries including pthreads. Key features covered include threads, mutual exclusion locks, condition variables, and examples of implementing a bounded buffer for inter-thread communication.
Lenses and Prisms in Swift - Elviro Rocca - Codemotion Rome 2018 Codemotion
The concept of functional Lens has become pretty popular in functional programming circles, and there are already good contributions for applying lenses to other, traditionally imperative/OO contexts. I’d like to offer a more in depth view on why lenses can be useful in Swift, and also talk about an associated concept called Prism. Let’s consider some practical problems and confront an idiomatic/imperative approach to the one based on lenses and prisms.
The document discusses various micro-optimizations that can be made in Java code to improve performance, including:
1. Avoiding boxing/unboxing of primitives, using primitive types instead of object wrappers when possible.
2. Using custom parsing methods instead of built-in String/regex methods like split(), trim(), equals() which have higher overhead.
3. Reducing object allocations by reusing objects/arrays when possible, avoiding unnecessary object creations, and using primitive arrays over object arrays.
4. Leveraging intrinsic methods, avoiding interpretation overhead through direct calls, and bypassing virtual method calls when the implementation is known.
This document discusses the use of deterministic simulation to test distributed systems. It describes how Flow, a programming language extension to C++, can be used to simulate concurrency and external communications deterministically. This allows debugging a simulation instead of the live distributed system. Key aspects of the simulation include single-threaded pseudo-concurrency, simulating external connections and files, and ensuring all control flow is deterministic based only on inputs. The simulator is used to run tests and simulated disasters to uncover bugs in a more efficient manner than real world testing alone.
This document provides an overview of writing clean code, focusing on readability, code style, naming conventions, code comments, control structures, functions/methods, classes, and modules. Key points include formatting code for readability, using explicit and descriptive naming, minimizing comments by ensuring code is self-explanatory, limiting nested control structures and side effects, following single responsibility and encapsulation principles, and leveraging software patterns.
The document provides an overview of new features in WebSphere Message Broker v6.x compared to earlier versions. Some key highlights include:
- Support for configuration without a database and on multiple platforms beyond just Windows.
- Enhanced Java Compute Nodes that allow using third party Java libraries for transformations, routing, filtering, and other tasks.
- New security features like identity extraction and authentication from messages.
- Extended use of XPath for node configuration and accessing message contents from Java code.
JS Fest 2019. Thomas Watson. Post-Mortem Debugging in Node.jsJSFestUA
Post-Mortem debugging is a really powerful technique that allows you, through the use of several tools, to take a memory dump when an issue occurs in your application and later analyze it offline.
The talk will primarily focus on llnode and how you can use this tool to better understand why a Node.js process is behaving odd or is crashing.
The document discusses various primitive data types including numeric, boolean, character, and string types. It describes integers, floating point numbers, complex numbers, decimals, booleans, characters, and strings. It also covers array types like static, dynamic, and associative arrays. Other topics include records, slices, and unions.
The document discusses various primitive data types including numeric, boolean, character, and string types. It describes integer types like byte, short, int that can store negative numbers using two's complement. Floating point types are represented as fractions and exponents. Boolean types are either true or false. Character types are stored as numeric codes. String types can have static, limited dynamic, or fully dynamic lengths. User-defined types like enumerations and subranges are also covered. The document also discusses array types including their initialization, operations, and implementation using row-major and column-major ordering. Associative arrays are described as unordered collections indexed by keys. Record and union types are summarized.
This document discusses transactions in Grails, including what transactions are, how to use transactions in Grails services through the @Transactional annotation, transaction isolation levels, propagation types, unintentionally bypassing the bean proxy, Spring classes for working with transactions, and two-phase commit for multiple databases. Key points covered include using the @Transactional annotation on Grails services, the various configuration options for @Transactional like isolation and propagation, and Spring utility classes like TransactionSynchronizationManager and TransactionAspectSupport.
The document provides templates and examples for creating Swing-based GUI applications, servlets, Java Server Pages (JSP), Java Database Connectivity (JDBC), Java Server Faces (JSF), Enterprise Java Beans (EJB), Hibernate, Struts, and web services in Java. It includes templates for common GUI components, servlets, JSP tags, database queries, managed beans, navigation rules, entity beans, Hibernate mappings, actions, and web service providers/consumers.
Good and Bad Code
The Broken Window Theory
The Grand Redesign in the Sky
The Sushi Chef Rule
The Hotel Room Rule
The Boy Scout Rule
OOP Patterns and Principles
SOLID Principles
How to measure clean code?
Tools
The document discusses the scripting capabilities of Groovy and how it simplifies scripting compared to Java. Groovy allows separating code into simple scripts without unnecessary class and method definitions. It supports various approaches for running scripts, including via a GroovyShell, GroovyScriptEngine, or by implementing the JSR-223 scripting API. Groovy also allows predefining variables and methods in a script's binding to make domain-specific languages more natural to use.
This document discusses the good parts of Javascript. It argues that while Javascript has some design mistakes and inconsistencies due to its rushed creation, it is a powerful and misunderstood language. The document highlights some of Javascript's good features, including functions as first-class objects, closures, objects and prototypal inheritance, and arrays. It advocates focusing on Javascript's strengths rather than its weaknesses.
The document discusses different approaches to handling JavaScript and AJAX functionality in Rails applications. It begins by showing how to use Rails' remote_form_for helper to generate JavaScript and AJAX code inline. It then demonstrates how to handle AJAX requests by binding JavaScript directly. The document also explores using JSON to return data from the server and the RJS format for generating JavaScript responses. Overall it provides examples of incrementally moving away from Rails' default JavaScript handling towards binding JavaScript directly.
The document discusses the evolution of the Rails framework from version 3 to the present. It describes how Rails 3 transitioned from being vaporware to becoming fully featured and stable. It provides examples of how ActiveSupport and ActionController were modularized with clear dependencies between components like ActionDispatch, AbstractController, and ActionController. The document also shows the organization of files within different Rails components and how rendering works in ActionController.
This document discusses test-driven development (TDD) in Merb applications. It emphasizes that tests should focus on the essential functionality and behavior that the developer cares about, rather than implementation details. Tests should continue passing even as the code is refactored. The document provides examples of refactoring code while keeping tests passing. It also suggests ways to make testing easier, such as adding helper methods to simplify request assertions and maintain test session state.
The document discusses why object-oriented jQuery code should be avoided. It recommends using an event-driven approach instead, where components trigger events to communicate rather than calling methods directly. This fits more cleanly with asynchronous requirements and how users typically interact with elements like autocompleters. The document provides an example of building tab functionality in an event-driven way by binding to click and keypress events that trigger a tabactivate event.
Making your oss project more like railsYehuda Katz
This document contains summaries of discussions about open source software projects. Some key points discussed include optimizing for developer happiness initially even if it locks users in, the importance of early adoption to stress test software, and allowing different contributors to care about different aspects of a project rather than just what the original creator cares about. Commercial activity is seen as growing the ecosystem.
Slides from a tutorial I gave at ETech 2006. Notes to accompany these slides can be found here: http://simonwillison.net/static/2006/js-reintroduction-notes.html
Gisting is an implementation of Google\'s MapReduce framework for processing and extracting useful information from very large data sets. At the time of this writing, the code is available for PREVIEW at http://github.com/mchung/gisting. I am currently working to release this framework for general usage.
The document summarizes changes between Ruby 1.8 and Ruby 1.9. Key changes include ordered hashes, new hash syntax, external iterators using Enumerators, better encoding support through M17N, and changes to the threading model. The document provides an overview of Ruby 1.8 vs 1.9 and dives into specific changes like new syntax, library changes, and new features in Ruby 1.9 like external iterators and improved internationalization support.
Introduction to Lisp. A survey of lisp's history, current incarnations and advanced features such as list comprehensions, macros and domain-specific-language [DSL] support.
The document provides an overview of functional programming concepts including:
- Functional languages like Haskell, Scala, Clojure, F#, Erlang, and Lisp/Scheme
- Concepts of immutability, concurrency, side effects, and using monads to deal with side effects
- Examples demonstrating functional programming techniques like pattern matching, immutable collections, message passing actors, and software transactional memory (STM)
Beijing Perl Workshop 2008 Hiveminder Secret SauceJesse Vincent
Template::Declare is a pure Perl templating engine that allows templates to be treated like code. Templates can be refactored, use object orientation and mixins. Tags are implemented as closures that can output content immediately or return closures. CSS::Squish is a CSS compiler that combines multiple small CSS files into one large file for easier serving, improving performance by allowing browsers to cache the combined file.
This document is a JavaScript beginner tutorial that outlines topics including:
- The history and evolution of JavaScript from 1995 to present
- How JavaScript is used with HTML and CSS
- Common JavaScript types like numbers, strings, arrays, and objects
- Flow control with if/else statements and loops
- Functions and function declarations
- Advanced JavaScript concepts
The tutorial provides examples and explanations of core JavaScript concepts to help beginners learn the fundamentals of the language. It outlines the structure and flow of the content that will be covered.
The document summarizes the key changes and improvements in Ruby 1.9 compared to Ruby 1.8. Some of the major changes include faster performance and lower memory usage due to the new YARV virtual machine, new syntax features like lambda shorthand and implicit calling, changes to standard library methods like send no longer calling private methods, and encoding improvements to better support international characters.
Hiveminder - Everything but the Secret SauceJesse Vincent
Ten tools and techniques to help you:
Find bugs faster バグの検出をもっと素早く
Build web apps ウェブアプリの構築
Ship software ソフトのリリース
Get input from users ユーザからの入力を受けつける
Own the Inbox 受信箱を用意する
今日の話
Introduction to Matlab Programming by Rayid Mojumder.
Download the code files from my Github repo:
https://github.com/rayid-mojumder/matlab-programming.git
A short description of Perly grammar processors leading up to Regexp::Grammars. Develops two R::G modules, one for single-line logfile entries, another for larger FASTA format entries in the NCBI "nr.gz" file. The second example shows how to derive one grammar from another by overriding tags in the base grammar.
This document provides an overview and agenda for a presentation on MySQL Proxy. MySQL Proxy is a transparent proxy server that allows intercepting and modifying MySQL traffic. It uses the Lua scripting language to intercept queries, inject new queries, and alter results. The presentation covers the basic principles of MySQL Proxy and Lua scripting, demonstrates how to use Lua scripts to debug queries and add new functionality like load balancing. It also provides resources for tutorials, example scripts, and testing MySQL Proxy.
This document summarizes the key changes between Ruby 1.8 and Ruby 1.9. Some major changes include improved performance, new syntax features like hash and proc literals, changes to the parser and standard library, improved regular expressions, and new enumerable methods. Ruby 1.9 also introduced better multilingual support through encoding changes to strings. Overall, the document outlines many backwards incompatible changes and warns that Ruby 1.9 is transitional as it prepares for Ruby 2.0.
This document provides an overview of JRuby, which is a Ruby implementation that runs on the Java Virtual Machine (JVM). It discusses key aspects of JRuby like its compatibility with Ruby, access to Java libraries, integration with Java code, and usage in applications like Rails. Specific topics covered include JRuby fundamentals, dynamic typing, classes and modules, mixins, Java integration features, testing Java code from Ruby, and calling Ruby from Java using JSR-223.
The document discusses various techniques for optimizing the performance of embedded Ruby (ERuby) templates. It describes 7 iterations of improvements to "MyEruby" that reduced the processing time from over 69 seconds to under 1 second. The optimizations included avoiding line splitting, replacing parsing with patterns, tuning regular expressions, inline expansion and array buffers.
Rapid Development with Ruby/JRuby and Railselliando dias
This document discusses Ruby and Rails development. It provides an overview of Ruby as a scripting language created by Yukihiro Matsumoto in 1993 with a focus on readability. Key aspects of Ruby covered include conventions, classes, symbols, closures, duck typing, and metaprogramming. The document also discusses how JRuby allows Java developers to use Ruby on the JVM and benefit from Ruby tools like Rails.
This document discusses techniques for improving the performance of SproutCore applications. Some key points include:
1. Keeping intermediate state in JavaScript objects rather than the DOM to avoid unnecessary re-renders.
2. Materializing objects from JSON data only when needed to avoid copying large amounts of unused data.
3. Following speed guidelines like minifying files, using a CDN, setting caching headers to optimize delivery of assets to users.
Writing Fast Client-Side Code: Lessons Learned from SproutCoreYehuda Katz
The SproutCore framework has evolved over the past five years to be an extremely high-performance framework that focuses on making it possible to build native-like applications in the browser.
This means handling problems like working with extremely large data-sets, inconsistent connectivity, and complex DOMs. Lately, it has meant figuring out how to properly use new browser features that can make a big difference to perceived performance, like hardware acceleration.
In this talk, Yehuda will cover some of the techniques that SproutCore has used historically to enable extremely complex applications to perform well in the browser, as well as what new technologies the team is looking at to leverage the latest browser technologies in building compelling content for the web.
The document discusses the benefits of using a framework like SproutCore for building large, complex web applications. It outlines how SproutCore separates an application into distinct Models, Views, and Controllers. Models manage the application data, Views handle DOM manipulation and display, and Controllers tie everything together. This isolation of concerns makes the code more modular and reusable, preventing views from becoming tangled together ("spaghetti code"). The document provides an example of how SproutCore implements a Twitter-like following feature with isolated, reusable Views, Models, and bindings between them to update automatically on data changes.
This document provides an overview of routing changes in Rails 3, including:
- Matching routes using "match" instead of "map.connect" and optional segments.
- Namespaces, scopes, and constraints for organizing and restricting routes.
- Default RESTful routes and generating resources.
- Redirects can now be specified as Rack apps or Procs.
- Mounting other Rack endpoints at specific paths.
The document discusses why object-oriented jQuery code should be avoided. It recommends using an event-driven approach instead, where components trigger events to communicate rather than calling methods directly. This fits more cleanly with asynchronous requirements and how users typically interact with elements like autocompleters. The document provides an example of building tab functionality in an event-driven way by binding to click and keypress events that trigger a tabactivate event.
Rails 3 provides a concise overview of changes in Rails 3 including maintaining MVC structure and RESTful routing while improving areas like file structure, block helpers, routing and constraints, ActiveRecord querying, resources routing, and ActionMailer delivery. Key changes include a more Rack-like implementation, chainable ActiveRecord scopes, and pagination and layout support in ActionMailer.
The document discusses the performance of Ruby and Rails frameworks. While Ruby is acknowledged to be a slower language, several contributors note that performance improvements are underway and hardware continues to get faster. Merb 2.0 is presented as focusing on modularity, integration, and rapid prototyping. Contributors are thanked for their work on Merb.
This document provides an overview of the Merb web framework. Some key points:
- Merb emphasizes efficiency and hackability over being a complete monolithic framework
- It aims to have minimal footprint to give apps more system resources
- It is based on Rack and allows interaction with various web servers
- Merb includes routing, request handling, and rendering functionality
- Mailing functionality is also included and mailers work similarly to controllers
- The modularity of Merb allows flexibility in customizing various aspects
This document provides an overview of DataMapper, an object-relational mapper (ORM) library for Ruby applications. It summarizes DataMapper's main features such as associations, migrations, database adapters, naming conventions, validations, custom types and stores. The document also provides examples of how to use DataMapper with different databases, import/export data, and validate models for specific contexts.
The document discusses how to integrate jQuery and JavaScript functionality into Ruby on Rails and Merb web applications. Key points include:
- Rails and Merb do not have built-in helpers for jQuery, but jQuery is easy to use and Ruby helpers can be written to support it
- The frameworks produce consistent markup that jQuery code can be written to add interactive behavior to
- Options like metadata can be passed to jQuery plugins via the markup generated by helpers
- Helpers, jQuery code, and techniques like the <base> tag allow JavaScript features to be unobtrusively integrated into the MVC frameworks
jQuery Presentation to Rails DevelopersYehuda Katz
This document summarizes jQuery, an open-source JavaScript library that simplifies HTML and JavaScript interactions. It discusses jQuery's features like DOM manipulation, events, effects, and AJAX capabilities. It also covers how to use jQuery with Ruby on Rails, including responding to Ajax requests and placing JavaScript code. The document advocates separating JavaScript behavior from HTML/CSS for maintainability.
Encryption in Microsoft 365 - ExpertsLive Netherlands 2024Albert Hoitingh
In this session I delve into the encryption technology used in Microsoft 365 and Microsoft Purview. Including the concepts of Customer Key and Double Key Encryption.
Unlocking Productivity: Leveraging the Potential of Copilot in Microsoft 365, a presentation by Christoforos Vlachos, Senior Solutions Manager – Modern Workplace, Uni Systems
A tale of scale & speed: How the US Navy is enabling software delivery from l...sonjaschweigert1
Rapid and secure feature delivery is a goal across every application team and every branch of the DoD. The Navy’s DevSecOps platform, Party Barge, has achieved:
- Reduction in onboarding time from 5 weeks to 1 day
- Improved developer experience and productivity through actionable findings and reduction of false positives
- Maintenance of superior security standards and inherent policy enforcement with Authorization to Operate (ATO)
Development teams can ship efficiently and ensure applications are cyber ready for Navy Authorizing Officials (AOs). In this webinar, Sigma Defense and Anchore will give attendees a look behind the scenes and demo secure pipeline automation and security artifacts that speed up application ATO and time to production.
We will cover:
- How to remove silos in DevSecOps
- How to build efficient development pipeline roles and component templates
- How to deliver security artifacts that matter for ATO’s (SBOMs, vulnerability reports, and policy evidence)
- How to streamline operations with automated policy checks on container images
Removing Uninteresting Bytes in Software FuzzingAftab Hussain
Imagine a world where software fuzzing, the process of mutating bytes in test seeds to uncover hidden and erroneous program behaviors, becomes faster and more effective. A lot depends on the initial seeds, which can significantly dictate the trajectory of a fuzzing campaign, particularly in terms of how long it takes to uncover interesting behaviour in your code. We introduce DIAR, a technique designed to speedup fuzzing campaigns by pinpointing and eliminating those uninteresting bytes in the seeds. Picture this: instead of wasting valuable resources on meaningless mutations in large, bloated seeds, DIAR removes the unnecessary bytes, streamlining the entire process.
In this work, we equipped AFL, a popular fuzzer, with DIAR and examined two critical Linux libraries -- Libxml's xmllint, a tool for parsing xml documents, and Binutil's readelf, an essential debugging and security analysis command-line tool used to display detailed information about ELF (Executable and Linkable Format). Our preliminary results show that AFL+DIAR does not only discover new paths more quickly but also achieves higher coverage overall. This work thus showcases how starting with lean and optimized seeds can lead to faster, more comprehensive fuzzing campaigns -- and DIAR helps you find such seeds.
- These are slides of the talk given at IEEE International Conference on Software Testing Verification and Validation Workshop, ICSTW 2022.
Maruthi Prithivirajan, Head of ASEAN & IN Solution Architecture, Neo4j
Get an inside look at the latest Neo4j innovations that enable relationship-driven intelligence at scale. Learn more about the newest cloud integrations and product enhancements that make Neo4j an essential choice for developers building apps with interconnected data and generative AI.
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdfMalak Abu Hammad
Discover how MongoDB Atlas and vector search technology can revolutionize your application's search capabilities. This comprehensive presentation covers:
* What is Vector Search?
* Importance and benefits of vector search
* Practical use cases across various industries
* Step-by-step implementation guide
* Live demos with code snippets
* Enhancing LLM capabilities with vector search
* Best practices and optimization strategies
Perfect for developers, AI enthusiasts, and tech leaders. Learn how to leverage MongoDB Atlas to deliver highly relevant, context-aware search results, transforming your data retrieval process. Stay ahead in tech innovation and maximize the potential of your applications.
#MongoDB #VectorSearch #AI #SemanticSearch #TechInnovation #DataScience #LLM #MachineLearning #SearchTechnology
UiPath Test Automation using UiPath Test Suite series, part 6DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 6. In this session, we will cover Test Automation with generative AI and Open AI.
UiPath Test Automation with generative AI and Open AI webinar offers an in-depth exploration of leveraging cutting-edge technologies for test automation within the UiPath platform. Attendees will delve into the integration of generative AI, a test automation solution, with Open AI advanced natural language processing capabilities.
Throughout the session, participants will discover how this synergy empowers testers to automate repetitive tasks, enhance testing accuracy, and expedite the software testing life cycle. Topics covered include the seamless integration process, practical use cases, and the benefits of harnessing AI-driven automation for UiPath testing initiatives. By attending this webinar, testers, and automation professionals can gain valuable insights into harnessing the power of AI to optimize their test automation workflows within the UiPath ecosystem, ultimately driving efficiency and quality in software development processes.
What will you get from this session?
1. Insights into integrating generative AI.
2. Understanding how this integration enhances test automation within the UiPath platform
3. Practical demonstrations
4. Exploration of real-world use cases illustrating the benefits of AI-driven test automation for UiPath
Topics covered:
What is generative AI
Test Automation with generative AI and Open AI.
UiPath integration with generative AI
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
zkStudyClub - Reef: Fast Succinct Non-Interactive Zero-Knowledge Regex ProofsAlex Pruden
This paper presents Reef, a system for generating publicly verifiable succinct non-interactive zero-knowledge proofs that a committed document matches or does not match a regular expression. We describe applications such as proving the strength of passwords, the provenance of email despite redactions, the validity of oblivious DNS queries, and the existence of mutations in DNA. Reef supports the Perl Compatible Regular Expression syntax, including wildcards, alternation, ranges, capture groups, Kleene star, negations, and lookarounds. Reef introduces a new type of automata, Skipping Alternating Finite Automata (SAFA), that skips irrelevant parts of a document when producing proofs without undermining soundness, and instantiates SAFA with a lookup argument. Our experimental evaluation confirms that Reef can generate proofs for documents with 32M characters; the proofs are small and cheap to verify (under a second).
Paper: https://eprint.iacr.org/2023/1886
GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using Deplo...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
Enchancing adoption of Open Source Libraries. A case study on Albumentations.AIVladimir Iglovikov, Ph.D.
Presented by Vladimir Iglovikov:
- https://www.linkedin.com/in/iglovikov/
- https://x.com/viglovikov
- https://www.instagram.com/ternaus/
This presentation delves into the journey of Albumentations.ai, a highly successful open-source library for data augmentation.
Created out of a necessity for superior performance in Kaggle competitions, Albumentations has grown to become a widely used tool among data scientists and machine learning practitioners.
This case study covers various aspects, including:
People: The contributors and community that have supported Albumentations.
Metrics: The success indicators such as downloads, daily active users, GitHub stars, and financial contributions.
Challenges: The hurdles in monetizing open-source projects and measuring user engagement.
Development Practices: Best practices for creating, maintaining, and scaling open-source libraries, including code hygiene, CI/CD, and fast iteration.
Community Building: Strategies for making adoption easy, iterating quickly, and fostering a vibrant, engaged community.
Marketing: Both online and offline marketing tactics, focusing on real, impactful interactions and collaborations.
Mental Health: Maintaining balance and not feeling pressured by user demands.
Key insights include the importance of automation, making the adoption process seamless, and leveraging offline interactions for marketing. The presentation also emphasizes the need for continuous small improvements and building a friendly, inclusive community that contributes to the project's growth.
Vladimir Iglovikov brings his extensive experience as a Kaggle Grandmaster, ex-Staff ML Engineer at Lyft, sharing valuable lessons and practical advice for anyone looking to enhance the adoption of their open-source projects.
Explore more about Albumentations and join the community at:
GitHub: https://github.com/albumentations-team/albumentations
Website: https://albumentations.ai/
LinkedIn: https://www.linkedin.com/company/100504475
Twitter: https://x.com/albumentations
In his public lecture, Christian Timmerer provides insights into the fascinating history of video streaming, starting from its humble beginnings before YouTube to the groundbreaking technologies that now dominate platforms like Netflix and ORF ON. Timmerer also presents provocative contributions of his own that have significantly influenced the industry. He concludes by looking at future challenges and invites the audience to join in a discussion.
51. class User
def self.current=(user)
Thread.current[:user] = user
end
def self.current
Thread.current[:user]
end
end
class Foo < Merb::Controller
before do
User.current = session.user
end
end
79. # This is a stub method so plugins can
# implement param filtering if they want.
#
# ==== Parameters
# params<Hash{Symbol => String}>::
# A list of params
#
# ==== Returns
# Hash{Symbol => String}::
# A new list of params, filtered as desired
#
# :api: plugin
# @overridable
def self._filter_params(params)
params
end
80. class Articles < Application
params_accessible :article =>
[:title, :body]
end
81. class Articles < Application
params_accessible :article =>
[:title, :body]
end
82. class Articles < Application
def self._filter_params(params)
# deep_clone
ret =
Marshal.load(Marshal.dump(params))
ret[:post].reject! do |k,v|
!k.in?(:title, :body)
end
end
end
83. class Articles < Application
def self._filter_params(params)
# deep_clone
ret =
Marshal.load(Marshal.dump(params))
ret[:post].reject! do |k,v|
!k.in?(:title, :body)
end
end
end
84. # :api: public
# @overridable
def _template_location(ctx, type, ctrlr)
_conditionally_append_extension(
ctrlr ?
quot;#{ctrlr}/#{ctx}quot; :
quot;#{ctx}quot;, type)
end
85. class Articles < Application
def self._template_location(
ctx, type, ctrlr)
quot;#{ctrlr}.#{ctx}.#{type}quot;
end
end
86. class Articles < Application
def self._template_location(
ctx, type, ctrlr)
quot;#{ctrlr}.#{ctx}.#{type}quot;
end
end
87. class Articles < Application
def self._template_location(
t”
ay
ctx, type, ctrlr)
l ou
r= “
ro lle
nt
quot;#{ctrlr}.#{ctx}.#{type}quot;
co
end
end
96. def _slice_template_location(ctx, type, ctrlr)
if ctrlr && ctrlr.include?('/')
# skip first segment if given (which is the module name)
segments = ctrlr.split('/')
quot;#{segments[1,segments.length-1].join('/')}/#{ctx}.#{type}quot;
else
# default template location logic
_template_location(ctx, type, ctrlr)
end
end
121. module MyApp
class Resource < Merb::Resource
def list(klass)
klass.all
end
def get(klass, ids)
klass.get(ids)
end
def authorized?(namespace, *args)
user == quot;wycatsquot;
end
def user
request.session.user
end
end
end