- The document describes the author's experience working on a Ruby project for the first time over the course of a month at his job. He was tasked with building a REST wrapper API to make developers' lives easier by handling annoying request signing logic.
- To complete the project, the author learned Ruby by reading books and documentation, setting up the project with Bundler and Rake, writing tests with RSpec and Guard, and considering options for request handling, response objects, and project structure before ultimately releasing the API on GitHub. The author found Ruby enjoyable to learn but encountered some challenges around mutability and "magic" that caused bugs.
This document discusses building a real-time geolocation game called MapAttack using the Geoloqi API and platform. It describes some initial issues encountered with the game server handling concurrent traffic and real-time updates. It then explains how using Node.js, EventMachine, and Geoloqi's publish/subscribe system helped address these issues by making the server asynchronous and event-driven. The document advocates for keeping relevant data outside persistent stores for better performance and discusses using high-performance hardware as an alternative to scaling database infrastructure. It promotes Geoloqi and building other real-time geolocation applications and games.
Infrastructure as code might be literally impossible part 2ice799
The document discusses various issues with infrastructure as code including complexities that arise from software licenses, bugs, and inconsistencies across tools and platforms. Specific examples covered include problems with SSL and APT package management on Debian/Ubuntu, Linux networking configuration difficulties, and inconsistencies in Python packaging related to naming conventions for packages containing hyphens, underscores, or periods. Potential causes discussed include legacy code, lack of time for thorough testing and bug fixing, and economic pressures against developing fully working software systems.
Ruby developers need to stop using EventMachine. It's the wrong direction.
Lost in the "Threads vs Event Driven vs Process Spawning" debate is that you can combine them! Learn how Celluloid is improving thread programming by abstracting them using a higher level framework called Celluloid, how you can use Celluloid::IO to throw a reactor pattern into a thread. Using this approach, you can take advantage of threading and use all CPU power on a machine with JRuby or Rubinius. I also discuss the future of distributed objects and computing, and where I think things are going.
Node.js: Patterns and Opinions discusses Node.js principles and best practices. It emphasizes that Node.js is built on JavaScript and uses non-blocking I/O with callbacks to handle requests asynchronously. It recommends avoiding slowness, ignoring errors, and focusing on portability, small modular parts, and an open community approach. The future of Node.js involves continued improvements to core modules like HTTP and new versions of underlying technologies.
This document discusses using Node.js and Redis to build a real-time web application. Ruby code is used to model users who can follow each other. When a user updates their status, Redis publishes the update to followers' timelines. Node.js code subscribes to Redis channels and sends updates to connected clients in real-time via websockets. This allows building a Twitter-like application where the web interface updates without reloading as users publish new statuses.
We're now living the golden age of JavaScript. An increasingly number of people are seeing it as a complete language. Therefore, agile development practices are now being adapted and applied to JavaScript code production. However, there has been a lack of support tools in the JS ecosystem, compared to what can be found on other platforms.
A year ago, native BDD solutions similar to Cucumber were almost inexistant. Yet the need for it was manifest. It didn't take me long before I proposed and started hacking on the port of our favourite cucurbitaceae.
Cucumber.js is a native JavaScript implementation of Cucumber. It is a strict port that can run on any JavaScript environment. It runs on Node.js as well as within any browsers, making it virtually serviceable against everything producing JavaScript and HTML (Node.js, Ruby on Rails, PHP, .Net, etc.).
This is an introduction to the young Cucumber.js. After briefly exposing the history and goals of the project, I'll demonstrate how to write features, step definitions, hooks, support code, how to invoke it from both Node.js and browser environments.
Presented at:
- CukeUp! 2012: http://skillsmatter.com/podcast/agile-testing/cucumber-js-cuke-up-your-javascript
- LNUG June 2012: http://lnug.org/
Node.js is a server-side JavaScript platform for easily building fast, scalable network applications. It uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, especially for real-time web applications with long-running operations. Node.js applications are written in JavaScript and can be run within the Node.js runtime on different platforms. Common uses of Node.js include web development, real-time applications, IoT, and scripting or build tasks.
This document discusses building a real-time geolocation game called MapAttack using the Geoloqi API and platform. It describes some initial issues encountered with the game server handling concurrent traffic and real-time updates. It then explains how using Node.js, EventMachine, and Geoloqi's publish/subscribe system helped address these issues by making the server asynchronous and event-driven. The document advocates for keeping relevant data outside persistent stores for better performance and discusses using high-performance hardware as an alternative to scaling database infrastructure. It promotes Geoloqi and building other real-time geolocation applications and games.
Infrastructure as code might be literally impossible part 2ice799
The document discusses various issues with infrastructure as code including complexities that arise from software licenses, bugs, and inconsistencies across tools and platforms. Specific examples covered include problems with SSL and APT package management on Debian/Ubuntu, Linux networking configuration difficulties, and inconsistencies in Python packaging related to naming conventions for packages containing hyphens, underscores, or periods. Potential causes discussed include legacy code, lack of time for thorough testing and bug fixing, and economic pressures against developing fully working software systems.
Ruby developers need to stop using EventMachine. It's the wrong direction.
Lost in the "Threads vs Event Driven vs Process Spawning" debate is that you can combine them! Learn how Celluloid is improving thread programming by abstracting them using a higher level framework called Celluloid, how you can use Celluloid::IO to throw a reactor pattern into a thread. Using this approach, you can take advantage of threading and use all CPU power on a machine with JRuby or Rubinius. I also discuss the future of distributed objects and computing, and where I think things are going.
Node.js: Patterns and Opinions discusses Node.js principles and best practices. It emphasizes that Node.js is built on JavaScript and uses non-blocking I/O with callbacks to handle requests asynchronously. It recommends avoiding slowness, ignoring errors, and focusing on portability, small modular parts, and an open community approach. The future of Node.js involves continued improvements to core modules like HTTP and new versions of underlying technologies.
This document discusses using Node.js and Redis to build a real-time web application. Ruby code is used to model users who can follow each other. When a user updates their status, Redis publishes the update to followers' timelines. Node.js code subscribes to Redis channels and sends updates to connected clients in real-time via websockets. This allows building a Twitter-like application where the web interface updates without reloading as users publish new statuses.
We're now living the golden age of JavaScript. An increasingly number of people are seeing it as a complete language. Therefore, agile development practices are now being adapted and applied to JavaScript code production. However, there has been a lack of support tools in the JS ecosystem, compared to what can be found on other platforms.
A year ago, native BDD solutions similar to Cucumber were almost inexistant. Yet the need for it was manifest. It didn't take me long before I proposed and started hacking on the port of our favourite cucurbitaceae.
Cucumber.js is a native JavaScript implementation of Cucumber. It is a strict port that can run on any JavaScript environment. It runs on Node.js as well as within any browsers, making it virtually serviceable against everything producing JavaScript and HTML (Node.js, Ruby on Rails, PHP, .Net, etc.).
This is an introduction to the young Cucumber.js. After briefly exposing the history and goals of the project, I'll demonstrate how to write features, step definitions, hooks, support code, how to invoke it from both Node.js and browser environments.
Presented at:
- CukeUp! 2012: http://skillsmatter.com/podcast/agile-testing/cucumber-js-cuke-up-your-javascript
- LNUG June 2012: http://lnug.org/
Node.js is a server-side JavaScript platform for easily building fast, scalable network applications. It uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, especially for real-time web applications with long-running operations. Node.js applications are written in JavaScript and can be run within the Node.js runtime on different platforms. Common uses of Node.js include web development, real-time applications, IoT, and scripting or build tasks.
Node.js is well-suited for applications that require lightweight concurrency and asynchronous I/O. It uses an event-driven, non-blocking model that makes it efficient for real-time applications with high concurrency needs, such as chat, live data feeds, and web site monitoring dashboards. While Node.js performs well for lightweight operations, heavier CPU-intensive tasks may be better suited for Java/J2EE due to its multi-threading capabilities. The Node.js ecosystem is growing rapidly but still less mature than Java/J2EE's established ecosystem.
This document provides an introduction to Node.js, including what it is, why it is useful, and how it works. Node.js is a platform that allows developers to build fast and scalable network applications using JavaScript. It uses an event-driven, non-blocking model that makes it lightweight and efficient for data-intensive real-time applications. Node.js shines for building real-time web apps with push technology over websockets, allowing two-way communication between client and server.
This document describes EhTrace, a tool for tracing the execution of binary programs through hooking and branch stepping. EhTrace uses the Windows VEH exception handler to single step programs by setting flags in the CPU context. It can be used to analyze program control flow at the basic block level for purposes like malware analysis, debugging, and code coverage. The document discusses techniques for maintaining control during tracing and fighting attempts by the target program to detect or alter the tracing.
Real-time Web Application with Socket.IO, Node.js, and RedisYork Tsai
This document summarizes a presentation about building real-time web applications using Socket.IO, Node.js, and Redis. It introduces Socket.IO for enabling real-time bidirectional communication across browsers. It then discusses using Redis for data persistence and as a pub/sub messaging system to integrate components and ensure scalability. The document provides code examples and addresses questions about authentication, load balancing, and configurations.
Rust is a systems programming language developed by Mozilla that provides memory safety without garbage collection. It uses concepts of ownership and borrowing to ensure memory safety issues like use-after-free do not occur. Rust offers zero-cost abstractions meaning abstraction mechanisms like generics have little to no performance overhead. It allows high levels of concurrency but requires memory references be valid during their entire lifetime.
Re-thinking Performance tuning with HTTP2Vinci Rufus
The document discusses how best practices for performance tuning with HTTP/1.1 may need to be re-thought with the introduction of HTTP/2. It provides an overview of how HTTP/2 addresses limitations of HTTP/1.1 like head-of-line blocking through features like multiplexing, binary framing, header compression and server push. It recommends approaches like keeping HTTP requests low and caching resources while avoiding past practices like excessive domain sharding or image sprites that are no longer needed with HTTP/2.
This document provides guidance on contributing to the Node.js core codebase. It recommends writing tests before submitting code changes, explains Node's test structure and best practices for writing good tests, and gives an overview of Node's core source code structure and key modules like http and tcp. The document concludes by assigning homework for attendees to read CONTRIBUTING.md, write a test, and submit a patch to fix a bug on GitHub.
An absolute beginners guide to node.js . Done for a presentation at college. The presentation contains data from various sources ,sources are noted at the end slide. please inform me any mistakes ,since at that time i was in a bit of hurry :)
Virtual machines allow developers to isolate their projects and their dependencies to avoid conflicts between different projects. They provide a consistent environment that is shareable and portable across different machines. Vagrant and Docker are two common tools for setting up virtual machines. While both tools create isolated virtual environments, Docker uses smaller incremental images and makes it easier to set up multi-machine environments compared to Vagrant. Ultimately, virtual machines could help standardize development environments and minimize setup times by allowing developers to use identical environments locally and in production.
Node.js: Whats the Big Deal? Presented and JS Meetup ChicagoAziz Ali
Presentation on Node.js. Whats the big deal with Node.js.
Talk about Event Driven, Non-Blocking, and Single Threaded Nature of Node.js
I also show the opportunity that Node.js opens up to make ALL kinds of apps on any platform including desktop applications.
- Ruby is no longer considered a "cool" language according to the author, who examines several languages that are currently popular including Swift, Rust, Go, Elixir, Julia, and Dart.
- Swift was created by Apple to replace Objective-C and adds modern features while removing the complexity of C. Rust was created to be safe, concurrent, and practical while combining high and low level capabilities. Go was created at Google to be understandable, productive, and scale well for networking and multiprocessing. Elixir builds on Erlang's concurrency model and adds a Ruby-like syntax. Julia targets scientific computing by combining speed and interactivity. Dart was created by Google to replace JavaScript but never gained
This document provides an overview and summary of Node.js. It discusses:
1) The history and implementations of server-side JavaScript including CommonJS and AMD specifications.
2) The benefits of Node.js including its event-driven and non-blocking I/O architecture which allows for high performance and parallel processing.
3) How to program in Node.js including handling CPU intensive tasks and popular Node packages like NPM, Express, and Grunt.
4) Live demonstrations of building a web app with Express and automating tasks with Grunt.
Node.js is a server-side JavaScript platform built on Google's V8 engine. It is non-blocking and asynchronous, making it suitable for data-intensive real-time applications. The document discusses how to install Node.js and its dependencies on Ubuntu, introduces key Node.js concepts like events and the event loop, and provides examples of popular Node.js packages and use cases.
Node.js is an asynchronous event-driven JavaScript runtime that allows JavaScript to be used on the server-side. It uses a non-blocking I/O model that makes it suitable for real-time web applications. WebSockets provide a standardized way for the browser and server to establish two-way communication. However, not all browsers support WebSockets yet. Socket.io addresses this by providing a WebSocket-like experience across all browsers through fallbacks like long-polling. It allows real-time applications to be developed more easily.
The document discusses Crate, a tool for packaging Ruby applications as standalone executables. Crate embeds Ruby, extensions, the standard library and application code into a single file. It describes how Crate packages the Ruby application and dependencies together and loads libraries from an Amalgalite database to avoid dependency on the filesystem. Some challenges of using Crate with frameworks like Rails are also outlined.
NodeJS is an open-source and cross-platform JavaScript runtime environment that allows JavaScript to be used for server-side scripting. The document discusses what NodeJS is, why it was created, how to use it, who uses it, and its use in China (CNodeJS). Key points are that NodeJS is used for building scalable network applications using non-blocking I/O and the JavaScript language, and that it has seen significant adoption in China from companies like Taobao and Sina for building web servers and real-time applications.
Building a REST API with Node.js and MongoDBVivochaLabs
Get the code at:
github.com/0xfede/lunch-o-clock
A quick introduction to MongoDB and Node.js and a sample application on how to use a rest API
by Federico Pinna
at Vivocha Tech Evenings 2014
2019 PHP Serbia - Boosting your performance with BlackfireMarko Mitranić
We aim to dispel the notion that large PHP applications tend to be sluggish, resource-intensive and slow compared to what the likes of Python, Erlang or even Node can do. The issue is not with optimising PHP internals - it's the lack of proper introspection tools and getting them into our every day workflow that counts! In this workshop we will talk about our struggles with whipping PHP Applications into shape, as well as work together on some of the more interesting examples of CPU or IO drain.
This document discusses building MapAttack, a real-time geolocation game, and describes some issues encountered with the initial implementation. It provides an overview of how Geoloqi was used to address problems with server blocking, concurrent traffic, and asynchronous processing. Advice is also given on database performance and scaling through approaches like caching frequently used data and using high-performance hardware.
Node.js is an asynchronous I/O library for JavaScript that aims to provide an easy way to build scalable network programs. It keeps slow operations from blocking other operations through non-blocking I/O and by utilizing a single-threaded event loop model. This allows Node.js applications to handle a large number of concurrent connections using a single process, without the overhead of threads. CommonJS modules provide portability for JavaScript libraries between Node.js and other environments like browsers.
The document introduces SD, a peer-to-peer bug tracking tool developed by Best Practical to allow tracking bugs offline and syncing work across devices. SD uses a decentralized model where each installation can pull changes from any other replica. It supports syncing with other bug trackers like RT, Trac and Google Code. The author argues that cloud services make users dependent while SD empowers fully offline and distributed work by syncing like users naturally share files.
IronRuby is a Ruby implementation that compiles Ruby code to .NET Intermediate Language. It allows Ruby code to run on the .NET Common Language Runtime and interoperate with .NET libraries. IronRuby was started by Microsoft but is now an open source project. It enables Ruby developers to build applications that integrate with existing .NET systems and libraries. However, IronRuby is still missing support for some Ruby standards like OpenSSL and has a lower test passing rate than MRI Ruby.
Node.js is well-suited for applications that require lightweight concurrency and asynchronous I/O. It uses an event-driven, non-blocking model that makes it efficient for real-time applications with high concurrency needs, such as chat, live data feeds, and web site monitoring dashboards. While Node.js performs well for lightweight operations, heavier CPU-intensive tasks may be better suited for Java/J2EE due to its multi-threading capabilities. The Node.js ecosystem is growing rapidly but still less mature than Java/J2EE's established ecosystem.
This document provides an introduction to Node.js, including what it is, why it is useful, and how it works. Node.js is a platform that allows developers to build fast and scalable network applications using JavaScript. It uses an event-driven, non-blocking model that makes it lightweight and efficient for data-intensive real-time applications. Node.js shines for building real-time web apps with push technology over websockets, allowing two-way communication between client and server.
This document describes EhTrace, a tool for tracing the execution of binary programs through hooking and branch stepping. EhTrace uses the Windows VEH exception handler to single step programs by setting flags in the CPU context. It can be used to analyze program control flow at the basic block level for purposes like malware analysis, debugging, and code coverage. The document discusses techniques for maintaining control during tracing and fighting attempts by the target program to detect or alter the tracing.
Real-time Web Application with Socket.IO, Node.js, and RedisYork Tsai
This document summarizes a presentation about building real-time web applications using Socket.IO, Node.js, and Redis. It introduces Socket.IO for enabling real-time bidirectional communication across browsers. It then discusses using Redis for data persistence and as a pub/sub messaging system to integrate components and ensure scalability. The document provides code examples and addresses questions about authentication, load balancing, and configurations.
Rust is a systems programming language developed by Mozilla that provides memory safety without garbage collection. It uses concepts of ownership and borrowing to ensure memory safety issues like use-after-free do not occur. Rust offers zero-cost abstractions meaning abstraction mechanisms like generics have little to no performance overhead. It allows high levels of concurrency but requires memory references be valid during their entire lifetime.
Re-thinking Performance tuning with HTTP2Vinci Rufus
The document discusses how best practices for performance tuning with HTTP/1.1 may need to be re-thought with the introduction of HTTP/2. It provides an overview of how HTTP/2 addresses limitations of HTTP/1.1 like head-of-line blocking through features like multiplexing, binary framing, header compression and server push. It recommends approaches like keeping HTTP requests low and caching resources while avoiding past practices like excessive domain sharding or image sprites that are no longer needed with HTTP/2.
This document provides guidance on contributing to the Node.js core codebase. It recommends writing tests before submitting code changes, explains Node's test structure and best practices for writing good tests, and gives an overview of Node's core source code structure and key modules like http and tcp. The document concludes by assigning homework for attendees to read CONTRIBUTING.md, write a test, and submit a patch to fix a bug on GitHub.
An absolute beginners guide to node.js . Done for a presentation at college. The presentation contains data from various sources ,sources are noted at the end slide. please inform me any mistakes ,since at that time i was in a bit of hurry :)
Virtual machines allow developers to isolate their projects and their dependencies to avoid conflicts between different projects. They provide a consistent environment that is shareable and portable across different machines. Vagrant and Docker are two common tools for setting up virtual machines. While both tools create isolated virtual environments, Docker uses smaller incremental images and makes it easier to set up multi-machine environments compared to Vagrant. Ultimately, virtual machines could help standardize development environments and minimize setup times by allowing developers to use identical environments locally and in production.
Node.js: Whats the Big Deal? Presented and JS Meetup ChicagoAziz Ali
Presentation on Node.js. Whats the big deal with Node.js.
Talk about Event Driven, Non-Blocking, and Single Threaded Nature of Node.js
I also show the opportunity that Node.js opens up to make ALL kinds of apps on any platform including desktop applications.
- Ruby is no longer considered a "cool" language according to the author, who examines several languages that are currently popular including Swift, Rust, Go, Elixir, Julia, and Dart.
- Swift was created by Apple to replace Objective-C and adds modern features while removing the complexity of C. Rust was created to be safe, concurrent, and practical while combining high and low level capabilities. Go was created at Google to be understandable, productive, and scale well for networking and multiprocessing. Elixir builds on Erlang's concurrency model and adds a Ruby-like syntax. Julia targets scientific computing by combining speed and interactivity. Dart was created by Google to replace JavaScript but never gained
This document provides an overview and summary of Node.js. It discusses:
1) The history and implementations of server-side JavaScript including CommonJS and AMD specifications.
2) The benefits of Node.js including its event-driven and non-blocking I/O architecture which allows for high performance and parallel processing.
3) How to program in Node.js including handling CPU intensive tasks and popular Node packages like NPM, Express, and Grunt.
4) Live demonstrations of building a web app with Express and automating tasks with Grunt.
Node.js is a server-side JavaScript platform built on Google's V8 engine. It is non-blocking and asynchronous, making it suitable for data-intensive real-time applications. The document discusses how to install Node.js and its dependencies on Ubuntu, introduces key Node.js concepts like events and the event loop, and provides examples of popular Node.js packages and use cases.
Node.js is an asynchronous event-driven JavaScript runtime that allows JavaScript to be used on the server-side. It uses a non-blocking I/O model that makes it suitable for real-time web applications. WebSockets provide a standardized way for the browser and server to establish two-way communication. However, not all browsers support WebSockets yet. Socket.io addresses this by providing a WebSocket-like experience across all browsers through fallbacks like long-polling. It allows real-time applications to be developed more easily.
The document discusses Crate, a tool for packaging Ruby applications as standalone executables. Crate embeds Ruby, extensions, the standard library and application code into a single file. It describes how Crate packages the Ruby application and dependencies together and loads libraries from an Amalgalite database to avoid dependency on the filesystem. Some challenges of using Crate with frameworks like Rails are also outlined.
NodeJS is an open-source and cross-platform JavaScript runtime environment that allows JavaScript to be used for server-side scripting. The document discusses what NodeJS is, why it was created, how to use it, who uses it, and its use in China (CNodeJS). Key points are that NodeJS is used for building scalable network applications using non-blocking I/O and the JavaScript language, and that it has seen significant adoption in China from companies like Taobao and Sina for building web servers and real-time applications.
Building a REST API with Node.js and MongoDBVivochaLabs
Get the code at:
github.com/0xfede/lunch-o-clock
A quick introduction to MongoDB and Node.js and a sample application on how to use a rest API
by Federico Pinna
at Vivocha Tech Evenings 2014
2019 PHP Serbia - Boosting your performance with BlackfireMarko Mitranić
We aim to dispel the notion that large PHP applications tend to be sluggish, resource-intensive and slow compared to what the likes of Python, Erlang or even Node can do. The issue is not with optimising PHP internals - it's the lack of proper introspection tools and getting them into our every day workflow that counts! In this workshop we will talk about our struggles with whipping PHP Applications into shape, as well as work together on some of the more interesting examples of CPU or IO drain.
This document discusses building MapAttack, a real-time geolocation game, and describes some issues encountered with the initial implementation. It provides an overview of how Geoloqi was used to address problems with server blocking, concurrent traffic, and asynchronous processing. Advice is also given on database performance and scaling through approaches like caching frequently used data and using high-performance hardware.
Node.js is an asynchronous I/O library for JavaScript that aims to provide an easy way to build scalable network programs. It keeps slow operations from blocking other operations through non-blocking I/O and by utilizing a single-threaded event loop model. This allows Node.js applications to handle a large number of concurrent connections using a single process, without the overhead of threads. CommonJS modules provide portability for JavaScript libraries between Node.js and other environments like browsers.
The document introduces SD, a peer-to-peer bug tracking tool developed by Best Practical to allow tracking bugs offline and syncing work across devices. SD uses a decentralized model where each installation can pull changes from any other replica. It supports syncing with other bug trackers like RT, Trac and Google Code. The author argues that cloud services make users dependent while SD empowers fully offline and distributed work by syncing like users naturally share files.
IronRuby is a Ruby implementation that compiles Ruby code to .NET Intermediate Language. It allows Ruby code to run on the .NET Common Language Runtime and interoperate with .NET libraries. IronRuby was started by Microsoft but is now an open source project. It enables Ruby developers to build applications that integrate with existing .NET systems and libraries. However, IronRuby is still missing support for some Ruby standards like OpenSSL and has a lower test passing rate than MRI Ruby.
An overview of Ruby, jRuby, Rails, Torquebox, and PostgreSQL that was presented as a 3 hour class to other programmers at The Ironyard (http://theironyard.com) in Greenville, SC in July of 2013. The Rails specific sections are mostly code samples that were explained during the session so the real focus of the slides is Ruby, "the rails way" / workflow / differentiators and PostgreSQL.
Fast, concurrent ruby web applications with EventMachine and EM::SynchronyKyle Drake
This document summarizes Kyle Drake's presentation on using EventMachine (EM) and EM::Synchrony to build fast, concurrent Ruby web applications without blocking I/O or callback hell. Key points include:
- EM implements the reactor pattern to handle blocking I/O without threads by using callbacks and kernel threads.
- EM::Synchrony avoids callback nesting by wrapping callbacks in fibers, allowing synchronous-looking code.
- Sinatra can be made concurrent by running each request in its own EM::Synchrony fiber with little code change.
- Ruby has strong options for building high-performance concurrent apps while maintaining productivity advantages over Node.js.
This document discusses Domain Specific Languages (DSLs) and their use in JavaScript. It begins by defining DSLs and providing examples of domain-specific lexicons. It then covers internal and external DSLs, and examples of JavaScript DSLs like JSSpec (for testing) and ActiveRecord.js (for object-relational mapping). The document concludes by discussing lessons learned from building DSLs in JavaScript, such as its lack of namespaces being a challenge but prototypal inheritance and object literals providing opportunities.
JavaScript is great, but let's face it, being stuck with just JavaScript in the browser is no fun.
Why not write and run Ruby in the browser, on the client, and on the server as part of your next web application?
This document provides an overview of the Java programming language. It discusses Java's history beginning as a language for consumer electronics and its adoption as a web programming language. The document outlines Java's features such as being object-oriented, portable, robust, secure, and having a large standard library. It provides examples of using Java for web applets, database access, distributed applications, and graphics. It also compares Java's performance to C++ and discusses how to get started with Java development.
Puppet Camp Atlanta 2014: DEV Toolsets for Ops (Beginner) - Puppet
The document discusses best practices for developing Puppet code in a DevOps environment. It recommends keeping code in branches in version control systems like Git or SVN, writing syntax-checked and tested code locally in virtual environments, and sharing code publicly through tools like Puppet Forge and privately through Hiera. Automating processes like testing, deployments, and sharing code are also emphasized.
These are the slides to a talk I gave at Pittsburgh techFest 2012. The topic was an overview of the Node.js framework, and how you can use it to build amazing things.
* See more of my work at http://www.codehenge.net
The document summarizes aspects of developing and maintaining the Ruby programming language, including its core team members, development resources, issue tracking process, testing procedures, release management, and security practices. The Ruby core team consists of around 90 committers and branch maintainers who work on various parts of the codebase. Development resources include build servers, documentation hosting, package distribution, and funding from various sponsors. Feature requests require use cases, attached patches, and approval from the project leader Matz. Releases aim to occur yearly on Christmas and follow a branch model with backported fixes. Security issues present ongoing challenges.
The document provides an introduction to the Ruby programming language given by Ezwan Aizat Bin Abdullah Faiz. Some key points covered include:
- Ruby's history and background, having been developed in Japan by Yukihiro Matsumoto with the aim of making it "natural, not simple".
- Basic features of Ruby like classes, inheritance, threads, iterators, closures, garbage collection and exception handling.
- Differences when coming to Ruby from other languages like Java and PHP, with Ruby being dynamically typed without static checking.
- Meta programming capabilities allow manipulating and extending the language.
- Ruby on Rails is highlighted as a popular web framework that utilizes conventions over configurations.
- Resources
The document discusses using mRuby and lightweight APIs for microservices. It introduces mRuby as a lightweight Ruby implementation that can be embedded into applications. It then demonstrates using mRuby with Nginx through the ngx_mruby module to build a simple microservice for handling API requests. Benchmark tests show the mRuby implementation serving requests faster than a standard Rack implementation in Ruby. However, some downsides of mRuby are also noted, such as needing to recompile when adding dependencies and lack of features like require that make code less dry.
The document is a presentation about Node.js, a JavaScript runtime built on Chrome's V8 JavaScript engine. It discusses how Node.js uses an event-driven, non-blocking I/O model that makes it particularly suited for real-time web applications and I/O-intensive applications compared to traditional threaded server models. It provides examples of Node.js features like asynchronous I/O, event loops, modules and the npm package manager.
Open innovation in software means Open Source (2011 remix)Bertrand Delacretaz
This document discusses open innovation and open source software. Open innovation means using both internal and external ideas and paths to market to advance technology. Open source refers to meritocratic communities that use open processes like open code and crowdsourcing. Open innovation and open source are complementary as innovation benefits from fast feedback, which open source provides through tools like issue trackers, mailing lists and real-time collaboration. Concrete examples of open source projects that enable fast feedback and collaboration are discussed.
My presentation from RedDotRubyConf 2013 in Singapore. Turned out to be a reflection on whether I'd still be a Rubyist in another 5 years, and what are the external trends that might change that. Short story: Yes! Of course. I'll always think like a Rubyist even though things will probably get more polyglot. The arena of web development is perhaps the most unpredictable though.
NodeJS provides an asynchronous, event-driven JavaScript runtime that allows JavaScript code to execute outside of a browser. While NodeJS has performance advantages over traditional platforms, it also has security risks due to JavaScript's global namespace, the ability to execute code dynamically via eval and other functions, and the fact that NodeJS processes run with elevated privileges by default. Developers must follow secure coding guidelines and use security frameworks to avoid exploits related to namespace pollution, runtime privilege escalation, cross-site scripting, and denial of service attacks. When used properly, NodeJS can provide a fast, scalable platform for building web applications and services.
Ruby on Rails is a web framework built on Ruby that aims to make web development simpler and more enjoyable. It was extracted from the Basecamp project management tool. Rails emphasizes conventions over configurations, separating concerns into models, views, and controllers, and following patterns that reduce repetition. Developers can get started with Rails by downloading the Ruby language and using resources like books, screencasts, and online communities to learn more. Popular hosting providers that support Rails include Heroku, Slicehost, and Dreamhost.
The document outlines why the author started using Ruby and provides an overview of the Ruby programming language and Ruby on Rails web application framework. It discusses how Ruby is a dynamic, object-oriented language designed to be elegant and efficient. Ruby on Rails makes it easy to build database-backed web applications according to the MVC pattern. The document also covers the Ruby ecosystem including interpreters, frameworks, libraries and tools, and discusses the future of Ruby and Rails.
Docker Online Meetup #3: Docker in ProductionDocker, Inc.
Jérôme Petazzoni discussed using Docker in production environments. He covered installing Docker on development machines and servers, building Docker images with Dockerfiles, distributing images through Docker Hub or private registries, using links or ambassador containers for service discovery, and orchestrating containers with tools like Kubernetes, Mesos, or configuration management systems. He also addressed logging, backups, and remote access of containers for sysadmin tasks.
Shipping Applications to Production in Containers with DockerJérôme Petazzoni
This document provides an overview and introduction to using Docker in production environments. It discusses how Docker can help with "solved" problems like installing, building, and distributing applications. It also covers important areas for production Docker usage, such as service discovery, orchestration, performance, configuration management, and sysadmin tasks. The document outlines various approaches in each area and notes that there are often multiple valid solutions to consider.
Consistent toolbox talks are critical for maintaining workplace safety, as they provide regular opportunities to address specific hazards and reinforce safe practices.
These brief, focused sessions ensure that safety is a continual conversation rather than a one-time event, which helps keep safety protocols fresh in employees' minds. Studies have shown that shorter, more frequent training sessions are more effective for retention and behavior change compared to longer, infrequent sessions.
Engaging workers regularly, toolbox talks promote a culture of safety, empower employees to voice concerns, and ultimately reduce the likelihood of accidents and injuries on site.
The traditional method of conducting safety talks with paper documents and lengthy meetings is not only time-consuming but also less effective. Manual tracking of attendance and compliance is prone to errors and inconsistencies, leading to gaps in safety communication and potential non-compliance with OSHA regulations. Switching to a digital solution like Safelyio offers significant advantages.
Safelyio automates the delivery and documentation of safety talks, ensuring consistency and accessibility. The microlearning approach breaks down complex safety protocols into manageable, bite-sized pieces, making it easier for employees to absorb and retain information.
This method minimizes disruptions to work schedules, eliminates the hassle of paperwork, and ensures that all safety communications are tracked and recorded accurately. Ultimately, using a digital platform like Safelyio enhances engagement, compliance, and overall safety performance on site. https://safelyio.com/
Unveiling the Advantages of Agile Software Development.pdfbrainerhub1
Learn about Agile Software Development's advantages. Simplify your workflow to spur quicker innovation. Jump right in! We have also discussed the advantages.
Artificia Intellicence and XPath Extension FunctionsOctavian Nadolu
The purpose of this presentation is to provide an overview of how you can use AI from XSLT, XQuery, Schematron, or XML Refactoring operations, the potential benefits of using AI, and some of the challenges we face.
Flutter is a popular open source, cross-platform framework developed by Google. In this webinar we'll explore Flutter and its architecture, delve into the Flutter Embedder and Flutter’s Dart language, discover how to leverage Flutter for embedded device development, learn about Automotive Grade Linux (AGL) and its consortium and understand the rationale behind AGL's choice of Flutter for next-gen IVI systems. Don’t miss this opportunity to discover whether Flutter is right for your project.
Hand Rolled Applicative User ValidationCode KataPhilip Schwarz
Could you use a simple piece of Scala validation code (granted, a very simplistic one too!) that you can rewrite, now and again, to refresh your basic understanding of Applicative operators <*>, <*, *>?
The goal is not to write perfect code showcasing validation, but rather, to provide a small, rough-and ready exercise to reinforce your muscle-memory.
Despite its grandiose-sounding title, this deck consists of just three slides showing the Scala 3 code to be rewritten whenever the details of the operators begin to fade away.
The code is my rough and ready translation of a Haskell user-validation program found in a book called Finding Success (and Failure) in Haskell - Fall in love with applicative functors.
Most important New features of Oracle 23c for DBAs and Developers. You can get more idea from my youtube channel video from https://youtu.be/XvL5WtaC20A
UI5con 2024 - Keynote: Latest News about UI5 and it’s EcosystemPeter Muessig
Learn about the latest innovations in and around OpenUI5/SAPUI5: UI5 Tooling, UI5 linter, UI5 Web Components, Web Components Integration, UI5 2.x, UI5 GenAI.
Recording:
https://www.youtube.com/live/MSdGLG2zLy8?si=INxBHTqkwHhxV5Ta&t=0
Project Management: The Role of Project Dashboards.pdfKarya Keeper
Project management is a crucial aspect of any organization, ensuring that projects are completed efficiently and effectively. One of the key tools used in project management is the project dashboard, which provides a comprehensive view of project progress and performance. In this article, we will explore the role of project dashboards in project management, highlighting their key features and benefits.
Preparing Non - Technical Founders for Engaging a Tech AgencyISH Technologies
Preparing non-technical founders before engaging a tech agency is crucial for the success of their projects. It starts with clearly defining their vision and goals, conducting thorough market research, and gaining a basic understanding of relevant technologies. Setting realistic expectations and preparing a detailed project brief are essential steps. Founders should select a tech agency with a proven track record and establish clear communication channels. Additionally, addressing legal and contractual considerations and planning for post-launch support are vital to ensure a smooth and successful collaboration. This preparation empowers non-technical founders to effectively communicate their needs and work seamlessly with their chosen tech agency.Visit our site to get more details about this. Contact us today www.ishtechnologies.com.au
UI5con 2024 - Bring Your Own Design SystemPeter Muessig
How do you combine the OpenUI5/SAPUI5 programming model with a design system that makes its controls available as Web Components? Since OpenUI5/SAPUI5 1.120, the framework supports the integration of any Web Components. This makes it possible, for example, to natively embed own Web Components of your design system which are created with Stencil. The integration embeds the Web Components in a way that they can be used naturally in XMLViews, like with standard UI5 controls, and can be bound with data binding. Learn how you can also make use of the Web Components base class in OpenUI5/SAPUI5 to also integrate your Web Components and get inspired by the solution to generate a custom UI5 library providing the Web Components control wrappers for the native ones.
Malibou Pitch Deck For Its €3M Seed Roundsjcobrien
French start-up Malibou raised a €3 million Seed Round to develop its payroll and human resources
management platform for VSEs and SMEs. The financing round was led by investors Breega, Y Combinator, and FCVC.
Liberarsi dai framework con i Web Component.pptxMassimo Artizzu
In Italian
Presentazione sulle feature e l'utilizzo dei Web Component nell sviluppo di pagine e applicazioni web. Racconto delle ragioni storiche dell'avvento dei Web Component. Evidenziazione dei vantaggi e delle sfide poste, indicazione delle best practices, con particolare accento sulla possibilità di usare web component per facilitare la migrazione delle proprie applicazioni verso nuovi stack tecnologici.
Everything You Need to Know About X-Sign: The eSign Functionality of XfilesPr...XfilesPro
Wondering how X-Sign gained popularity in a quick time span? This eSign functionality of XfilesPro DocuPrime has many advancements to offer for Salesforce users. Explore them now!
8 Best Automated Android App Testing Tool and Framework in 2024.pdfkalichargn70th171
Regarding mobile operating systems, two major players dominate our thoughts: Android and iPhone. With Android leading the market, software development companies are focused on delivering apps compatible with this OS. Ensuring an app's functionality across various Android devices, OS versions, and hardware specifications is critical, making Android app testing essential.
6. What was I supposed to build?
- Thin Rest Wrapper
- But why?
- Make developers life easier.
- Annoying request signing logic
- Document and provide examples for the APIs
26. Too much magic
- It was all great until this:
/hashie/dash.rb:41:in `block in property': wrong number of arguments (1 for 0)
(ArgumentError)
from /hashie-3.2.0/lib/hashie/hash.rb:48:in `flexibly_convert_to_hash'
from /hashie-3.2.0/lib/hashie/hash.rb:34:in `block in to_hash'
from /hashie-3.2.0/lib/hashie/hash.rb:20:in `each'
from /hashie-3.2.0/lib/hashie/hash.rb:20:in `to_hash'
from /hashie-3.2.0/lib/hashie/hash.rb:42:in `to_json'
Thin Rest Wrapper around a collection of API’s that Wix exposes to third party application developers.
How do you choose tools when you have no experience and no one to ask? You use google :) and find ruby toolbox. This really helped me and almost all (I’ll talk about exceptions in a minute) of the tools that used are based on the stats from this place.
IRB - Although scala has the repl and I always found it useful, what I loved about the IRB and found more convenient is the fact that you can simply require gems and play around with them.
Coming from the world of Scala/Java where you need to choose between maven gradle or sbt for your project using bundler and rake was like a dream come true. And what I truly loved about them is the simplicity and the fact that the dependency management is separated from the tasks part! No more xmls or spaghetti code for dependencies, build ,package and test tasks.
Guard running the tests. Amazing when coming from Scala!
No compiler no types I need to test everything! During my first week this was the attitude that I had and I wrote a whole bunch of unit tests that had nothing to do with behaviour! But I quickly realised that I’m trying swim against the tide here. I heard/read various opinions on how you should write more unit tests when you are coding in a dynamic language but what I actually found the most useful are integration tests!
But say you had a test that tested the system/component from the outside? Would that help? IMHO it might and it might help you catch bugs faster and thats why we need integration and e2e tests….
As we spoke just a minute more often than not we need to refactor some bits of the system or in this case library. This will involve changing sometimes multiple components and although unit tests are great in this case they were not enough for me to feel comfortable making those changes. Also early in that one month I found myself creating bugs :) and these tests made sure to keep me in line.
OK I realised I needed integration and end 2 end tests but I now had to add them to the project.
What I wanted was: 1. Fast integration tests to run with guard. 2. E2E tests to exercise the library against a test app.
After playing around a bit I realised that the tests in both cases are the same the only thing that was diferent is that I wanted the integration tests to run faster :) And as I already learned by now: There must be a GEM for it :) and there was VCR.
Its an awesome tool basically it records the HTTP interactions and enables you to re-execute them in a fast manner locally while you are developing. Exactly what I needed.
Another nice thing about VCR was that the interactions were saved as yaml files and were very readable so I found myself looking through them to resolve some issues both on the server and in the library iteslf.
OK now that I had the tests set up it was time to actually write the gem…
By this point I’ve already had a few weeks of coding in Ruby… The first impression that I had about the language was how easy it was to pick it up and how naturaly it was to write code in Ruby. The code that I would write was almost like english making it the most redable language I’ve had the pleasure to work with.
Not everything is pink in Ruby land though :) Mutability was something that I had to get used to coming from Scala.
Here is the outline of how I wanted the gem to look like:
One entry point…. meaning I the client would have to know only about a single class and easily pull it in.
Minimal configuration… again I wanted developers to be able to require the gem and be able to start using it in a matter of min without having to go through a ton of documentation.
Optional extensive configuration… for more advanced clients I wanted them to be able to configure anything from logging to http timeouts to headers.
With that in mind and having looked at a couple of examples :) I set out to write the gem.
First thing that I loved about Ruby was the modules! Lets look at the example of the structure that I was able to give to my code. So lets start with the client it pulls in the Rest API. The rest api defines the different groups of apis that it has. And finally lets look at the first one. One thing that was hard to get used to is that you can call methods from the parent object but that again comes down to me not being used to the dynamic nature of the language :)
Now that I had this walking skeleton in place it was time to actually make some http calls and make the first e2e test pass.
??similar to Scala traits they are similar in the sense that modules are mixins and mixins are traits that can have state.
Although the title of the slide looks like there was some battle :) between the two. To be honest there was not after maybe a day playing around with the two these were the takeaways:
REST Client is for sure easier to use… It has a simple interface BUT but you pay for that simplicity by the lack of extensibility.
This was the thing that made up my mind about Faraday! My code was encapsulated in small “racks” that I pluged in and they did one very specific job! For example the error handling [show slide].
And also it fit nicely with my initial idea to expose a fair amount of configuration to the advanced end user.
Once I had the the whole thing set up and got my first response back from the gem I was not very satisfied with the response… :) I got a hash back… this was not the usage I had in mind. How I actually wanted this gem to work is that the user would receive an object back that he can access. For example: [show example]
So I started creating this kind of objects by hand and added some parsing logic to populate them it looked great until moment I actually wanted to send a request to create a contact for example… and that looked like this [show example] and this was also not what I wanted… and if that was not enough I realised that I also need some validation on the objects.
And again before long I applied the most valuable lesson in Ruby that I’ve learned so far and that is: If you are doing something complicated stop there is a gem for it :D
And there was Introducing hashie the best of two worlds [show example] with hashie I was able to give the flexibility for developers to choose their own style in which they read or create objects.
I was making rapid progress with Hashie. Things were so easy :) I even took it a step further and generated some of the classes from a predefined json schema. Until I got this error. First things first this didnt tell me anything to be honest so I started debugging and after maybe a day or so I figured it out :) one of the responses that I was getting contained a field named method. And guess what hashie did when it found a field like that? Well it declared a method called method :) and kaboom you loose one of the base object methods. And its just a ticking bomb until this pops up somewhere on runtime.
Lets start off with the fact that I had to solve my problem. It was too late to go back and do a reafctor on the library because of one “small” issue. So I resorted to I suppose everyone in this room has done once or twice in their Ruby career and that is Monkey Patching. I suppose you have read heard argued on this subject so I wont take too much of your time and I will break my view on it down to 3 simple points.
Obviously the good part is that the language enabled me to go around an issue or to add functionality to a class where needed. This fits nicely with the OOP open closed principle.
Well the bad thing here is that I can override or practically erase a behaviour of any class. Thus violating the “closed for modification” part of the open closed principle.
Once you monkey patch for the first time it works like heroin :) you just want to do it more and every problem looks like a perfect fit for monkey patching. And if you are not carful you can endup with an ugly unmanageable code base.
And although I lack the experience to speak about this in the Ruby world we have something very similar in Scala called implicits which is basically allows you to extend a class with new behaviour. But what happens usually when you learn implicits for the first time is that you use them everywhere you go crazy with them. And then good luck reading the code or debugging through it.