The document discusses domain specific languages (DSLs) and how to build them. It covers key topics like the differences between external and internal DSLs, characteristics of DSLs like being context-driven and having fluent interfaces, and techniques for creating DSLs in Groovy like using categories and ExpandoMetaClass. Examples of DSLs in different languages and frameworks are provided. References for further reading on DSLs are listed at the end.
DeepPavlov is an open-source framework for the development of production-ready chat-bots and complex conversational systems, as well as NLP and dialog systems research.
Controlled Natural Language Generation from a Multilingual FrameNet-based Gra...Normunds Grūzītis
We present a currently bilingual but potentially multilingual FrameNet-based grammar library implemented in Grammatical Framework. The contribution of this paper is two-fold. First, it offers a methodological approach to automatically generate the grammar based on semantico-syntactic valence patterns extracted from FrameNet- annotated corpora. Second, it provides a proof of concept for two use cases illustrating how the acquired multilingual grammar can be exploited in different CNL applications in the domains of arts and tourism.
This is a survey about Dialog System, Question and Answering, including the 03 generations: (1) Symbolic Rule/Template Based QA; (2) Data Driven, Learning; (3) Data-Driven Deep Learning. It also presents the available Frameworks and Datas for Dialog Systems.
DeepPavlov is an open-source framework for the development of production-ready chat-bots and complex conversational systems, as well as NLP and dialog systems research.
Controlled Natural Language Generation from a Multilingual FrameNet-based Gra...Normunds Grūzītis
We present a currently bilingual but potentially multilingual FrameNet-based grammar library implemented in Grammatical Framework. The contribution of this paper is two-fold. First, it offers a methodological approach to automatically generate the grammar based on semantico-syntactic valence patterns extracted from FrameNet- annotated corpora. Second, it provides a proof of concept for two use cases illustrating how the acquired multilingual grammar can be exploited in different CNL applications in the domains of arts and tourism.
This is a survey about Dialog System, Question and Answering, including the 03 generations: (1) Symbolic Rule/Template Based QA; (2) Data Driven, Learning; (3) Data-Driven Deep Learning. It also presents the available Frameworks and Datas for Dialog Systems.
Deep Learning in practice : Speech recognition and beyond - MeetupLINAGORA
Retrouvez la présentation de notre Meetup du 27 septembre 2017 présenté par notre collaborateur Abdelwahab HEBA : Deep Learning in practice : Speech recognition and beyond
Speaker: Vitalii Braslavskyi, Software Engineer at Grammarly
Summary:
Today, the dominant approach to software engineering is an imperative one — the best practices have been proven over time. But the world is always evolving, and in order to evolve with it and remain as productive as possible, we need to continue searching for better tools to solve problems of increasing complexity.
In this talk, we'll discuss the tools and techniques of the .Net ecosystem that can help us to concentrate on the problem itself — not just on the intermediate steps (which have likely already been solved). We'll compare imperative and declarative approaches and assess solutions to problems.
We'll also offer examples of how engineers in Grammarly's Office Add-in team use these tools to improve the efficiency of our engineering and strengthen our solutions to the problems at hand.
Deep Learning for NLP (without Magic) - Richard Socher and Christopher ManningBigDataCloud
A tutorial given at NAACL HLT 2013.
Richard Socher and Christopher Manning
http://nlp.stanford.edu/courses/NAACL2013/
Machine learning is everywhere in today's NLP, but by and large machine learning amounts to numerical optimization of weights for human designed representations and features. The goal of deep learning is to explore how computers can take advantage of data to develop features and representations appropriate for complex interpretation tasks. This tutorial aims to cover the basic motivation, ideas, models and learning algorithms in deep learning for natural language processing. Recently, these methods have been shown to perform very well on various NLP tasks such as language modeling, POS tagging, named entity recognition, sentiment analysis and paraphrase detection, among others. The most attractive quality of these techniques is that they can perform well without any external hand-designed resources or time-intensive feature engineering. Despite these advantages, many researchers in NLP are not familiar with these methods. Our focus is on insight and understanding, using graphical illustrations and simple, intuitive derivations. The goal of the tutorial is to make the inner workings of these techniques transparent, intuitive and their results interpretable, rather than black boxes labeled "magic here". The first part of the tutorial presents the basics of neural networks, neural word vectors, several simple models based on local windows and the math and algorithms of training via backpropagation. In this section applications include language modeling and POS tagging. In the second section we present recursive neural networks which can learn structured tree outputs as well as vector representations for phrases and sentences. We cover both equations as well as applications. We show how training can be achieved by a modified version of the backpropagation algorithm introduced before. These modifications allow the algorithm to work on tree structures. Applications include sentiment analysis and paraphrase detection. We also draw connections to recent work in semantic compositionality in vector spaces. The principle goal, again, is to make these methods appear intuitive and interpretable rather than mathematically confusing. By this point in the tutorial, the audience members should have a clear understanding of how to build a deep learning system for word-, sentence- and document-level tasks. The last part of the tutorial gives a general overview of the different applications of deep learning in NLP, including bag of words models. We will provide a discussion of NLP-oriented issues in modeling, interpretation, representational power, and optimization.
Grammarly AI-NLP Club #2 - Recent advances in applied chatbot technology - Jo...Grammarly
Speaker: Jordi Carrera Ventura, Artificial Intelligence technologist at Telefónica R&D
Summary: Chatbots (aka conversational agents, spoken dialogue systems) allow users to interface with computers using natural language by simply asking questions or issuing commands.
Given a query, the chatbot builds a semantic representation of the input, transforms it into a logical statement, and performs all the necessary actions to fulfill the user's intent. Sometimes this simply means calculating an exact answer or retrieving a fact from a database, whereas other times it means building a contextual model and running a full-fledged conversation flow while keeping track of anaphoras and cross-references.
Besides the direct applications of chatbots in IoT (Amazon’s Alexa, Apple's Siri) and IT (the historical field of Information Retrieval as a whole can be seen as a sub-problem of spoken dialogue systems), chatbots' main appeal for technologists is their location at the intersection of all major Natural Language Processing technologies and many of the deepest questions in Cognitive Science today: semantic parsing, entity recognition, knowledge representation, and coreference resolution.
In this talk, I will explore those questions in the context of an applied industry setting, and I will introduce a framework suitable for addressing them, together with an overview of the state-of-the-art in chatbot technology and some original techniques.
Oplægget blev holdt ved et seminar i InfinIT-interessegruppen Højniveausprog til Indlejrede Systemer den 2. oktober 2013. Læs mere om interessegruppen her: http://infinit.dk/dk/interessegrupper/hoejniveau_sprog_til_indlejrede_systemer/hoejniveau_sprog_til_indlejrede_systemer.htm
Agile practitioners can be design avoidant! DDD helps improve communication through ubiquitous language; improve thinking through mapping patterns; and ensuring design and reality match.
Rob Davies talks about Apache Open Source Software for Financial Services at ...Skills Matter
In this talk Rob explains how open source from the Apache Software Foundation can achieve high performance and availability and reliable delivery of information across many diverse systems.
Find a podcast of Rob's talk here:
http://skillsmatter.com/podcast/cloud-grid/on-fuse-servicemix-activemq-cxf-and-camel/wd-506
Gradle is a flexible general purpose build system with a build-by-convention framework a la Maven on top. It uses Apache Ivy under the hood for its dependency management. Its build scripts are written in Groovy.
Deep Learning in practice : Speech recognition and beyond - MeetupLINAGORA
Retrouvez la présentation de notre Meetup du 27 septembre 2017 présenté par notre collaborateur Abdelwahab HEBA : Deep Learning in practice : Speech recognition and beyond
Speaker: Vitalii Braslavskyi, Software Engineer at Grammarly
Summary:
Today, the dominant approach to software engineering is an imperative one — the best practices have been proven over time. But the world is always evolving, and in order to evolve with it and remain as productive as possible, we need to continue searching for better tools to solve problems of increasing complexity.
In this talk, we'll discuss the tools and techniques of the .Net ecosystem that can help us to concentrate on the problem itself — not just on the intermediate steps (which have likely already been solved). We'll compare imperative and declarative approaches and assess solutions to problems.
We'll also offer examples of how engineers in Grammarly's Office Add-in team use these tools to improve the efficiency of our engineering and strengthen our solutions to the problems at hand.
Deep Learning for NLP (without Magic) - Richard Socher and Christopher ManningBigDataCloud
A tutorial given at NAACL HLT 2013.
Richard Socher and Christopher Manning
http://nlp.stanford.edu/courses/NAACL2013/
Machine learning is everywhere in today's NLP, but by and large machine learning amounts to numerical optimization of weights for human designed representations and features. The goal of deep learning is to explore how computers can take advantage of data to develop features and representations appropriate for complex interpretation tasks. This tutorial aims to cover the basic motivation, ideas, models and learning algorithms in deep learning for natural language processing. Recently, these methods have been shown to perform very well on various NLP tasks such as language modeling, POS tagging, named entity recognition, sentiment analysis and paraphrase detection, among others. The most attractive quality of these techniques is that they can perform well without any external hand-designed resources or time-intensive feature engineering. Despite these advantages, many researchers in NLP are not familiar with these methods. Our focus is on insight and understanding, using graphical illustrations and simple, intuitive derivations. The goal of the tutorial is to make the inner workings of these techniques transparent, intuitive and their results interpretable, rather than black boxes labeled "magic here". The first part of the tutorial presents the basics of neural networks, neural word vectors, several simple models based on local windows and the math and algorithms of training via backpropagation. In this section applications include language modeling and POS tagging. In the second section we present recursive neural networks which can learn structured tree outputs as well as vector representations for phrases and sentences. We cover both equations as well as applications. We show how training can be achieved by a modified version of the backpropagation algorithm introduced before. These modifications allow the algorithm to work on tree structures. Applications include sentiment analysis and paraphrase detection. We also draw connections to recent work in semantic compositionality in vector spaces. The principle goal, again, is to make these methods appear intuitive and interpretable rather than mathematically confusing. By this point in the tutorial, the audience members should have a clear understanding of how to build a deep learning system for word-, sentence- and document-level tasks. The last part of the tutorial gives a general overview of the different applications of deep learning in NLP, including bag of words models. We will provide a discussion of NLP-oriented issues in modeling, interpretation, representational power, and optimization.
Grammarly AI-NLP Club #2 - Recent advances in applied chatbot technology - Jo...Grammarly
Speaker: Jordi Carrera Ventura, Artificial Intelligence technologist at Telefónica R&D
Summary: Chatbots (aka conversational agents, spoken dialogue systems) allow users to interface with computers using natural language by simply asking questions or issuing commands.
Given a query, the chatbot builds a semantic representation of the input, transforms it into a logical statement, and performs all the necessary actions to fulfill the user's intent. Sometimes this simply means calculating an exact answer or retrieving a fact from a database, whereas other times it means building a contextual model and running a full-fledged conversation flow while keeping track of anaphoras and cross-references.
Besides the direct applications of chatbots in IoT (Amazon’s Alexa, Apple's Siri) and IT (the historical field of Information Retrieval as a whole can be seen as a sub-problem of spoken dialogue systems), chatbots' main appeal for technologists is their location at the intersection of all major Natural Language Processing technologies and many of the deepest questions in Cognitive Science today: semantic parsing, entity recognition, knowledge representation, and coreference resolution.
In this talk, I will explore those questions in the context of an applied industry setting, and I will introduce a framework suitable for addressing them, together with an overview of the state-of-the-art in chatbot technology and some original techniques.
Oplægget blev holdt ved et seminar i InfinIT-interessegruppen Højniveausprog til Indlejrede Systemer den 2. oktober 2013. Læs mere om interessegruppen her: http://infinit.dk/dk/interessegrupper/hoejniveau_sprog_til_indlejrede_systemer/hoejniveau_sprog_til_indlejrede_systemer.htm
Agile practitioners can be design avoidant! DDD helps improve communication through ubiquitous language; improve thinking through mapping patterns; and ensuring design and reality match.
Rob Davies talks about Apache Open Source Software for Financial Services at ...Skills Matter
In this talk Rob explains how open source from the Apache Software Foundation can achieve high performance and availability and reliable delivery of information across many diverse systems.
Find a podcast of Rob's talk here:
http://skillsmatter.com/podcast/cloud-grid/on-fuse-servicemix-activemq-cxf-and-camel/wd-506
Gradle is a flexible general purpose build system with a build-by-convention framework a la Maven on top. It uses Apache Ivy under the hood for its dependency management. Its build scripts are written in Groovy.
Using Language Oriented Programming to Execute Computations on the GPUSkills Matter
F# has a number of features that support language oriented programming (LOP) – the ability to create an abstract description of a problem then have this description executed in another environment. In this talk we’ll look at the design of an F# library that uses LOP techniques to a user execute matrix calculations either on the CPU or GPU. We’ll examine the features that F# provides to support this technique. We’ll start by taking a look at union types and active patterns, and then we’ll see how these are used by F#’s quotation system to give access to an abstract description of functions. Finally, we’ll see how these descriptions of functions can then be translated into computations the GPU understands and executed.
Neo4j is a graph database. It is an embedded, disk-based, fully transactional Java persistence engine that stores data structured in graphs rather than in tables. A graph (mathematical lingo for a network) is a flexible data structure that allows a more agile and rapid style of development.This graph database has got its own standalone server mode, based on interaction via REST.
RabbitMQ is a complete and highly reliable enterprise messaging system based on the emerging AMQP standard. It is licensed under the open source Mozilla Public License and has a platform-neutral distribution, plus platform-specific packages and bundles for easy installation.
In this talk, Alexis talks on use cases for cloud messaging.What is messaging and why it is useful for cloud computing? This talk will answer these questions by way of illustrating use cases from RabbitMQ customers.
Do you know what your enterprise apps get up to in their time off? Fighting fantasy, pick-your-path, hypermedia-driven, RESTful Web application adventures--of course.
In this dungeon delve I'll show how we can use hypermedia-driven Web applications to model rich workflows. We'll tackle the many-headed Hydra of HATEOAS, the “Hypermedia as the Engine of Application State” monster; level up through the Web services maturity heuristic; and meet the dwarves with grudges. As we explore the ruins of the enterprise BPM landscape, we'll learn how to model business processes as domain application protocols, implement them in terms of resource lifecycles, and advertise them using HTTP idioms, media types and link relation values.
ABOUT IAN ROBINSON
Ian is a principal consultant with ThoughtWorks, where he helps clients create sustainable service-oriented development capabilities that align business and IT from inception through to operation.
Following on from the previous LSUG talk we will take a look into how Scala uses an enhanced version of the Java interfaces called traits to add new functionality to not only your own classes but also to existing Java classes. This will go in depth on how to include multiple traits in a single class and why there is no multiple inheritance problems that have traditionally caused problems. as well has areas of pattern matching and generics If there is time, there will be a demo of Kevin's Autoproxy plugin and how traits are used a part of this library.
In startups, too many words & phrases exist. Here is a short curated list of startup terminology. Enjoy!
If you have any suggestions on things to add, email me at: lukejamesfitzpatrick@gmail.com
External or internal domain-specific languages (DSLs) or (fluent)
APIs? Whoever you are – a developer or a user of a DSL –
you usually have to choose side; you should not! What about
metamorphic DSLs that change their shape according to your
needs? Our 4-years journey of providing the "right" support
(in the domain of feature modeling), led us to develop an external
DSL, different shapes of an internal API, and maintain
all these languages. A key insight is that there is no one-size-fits-
all solution or no clear superiority of a solution compared
to another. On the contrary, we found that it does make sense
to continue the maintenance of an external and internal DSL.
Based on our experience and on an analysis of the DSL engineering
field, the vision that we foresee for the future of
software languages is their ability to be self-adaptable to the
most appropriate shape (including the corresponding integrated
development environment) according to a particular
usage or task. We call metamorphic DSL such a language,
able to change from one shape to another shape.
The talk has been presented at SPLASH conference in Portland (USA), Onward! Essays track.
Paper is here: https://hal.archives-ouvertes.fr/hal-01061576/fr
This presentation shows the concept of a Domain Specific Language in Ruby. A language that aims to solve specific problems, as opposed to general purpose languages that are used to software development in general. A simple syntax language, so natural to read, write and above all things, be easy to understand both for the computer as a human being. Expressing yourself in a language means that the point on semantic is more important to solve specific problems than to their interpreter to know what is going on.
Are you responsible for developing satellite on-board software? Are you the Dutch government and you have to efficiently implement the public benefits law? Are you a healthcare startup, developing companion apps that help patients through a treatment? Are you an insurance company struggling to create new, and evolve existing products quickly to keep up with the market? These are all examples of organisations who have built their own domain-specific programming language to streamline the development of applications that have a non-trivial algorithmic core. All have built their languages with Jetbrains MPS, an open source language development tool optimized for ecosystems of collaborating languages with mixed graphical, textual, tabular and mathematical notations. This talk has four parts. I start by motivating the need for DSLs based on real-world examples, including the ones above. I will then present a few high-level design practices that guide our language development work. Third, I will develop a simple language extension to give you a feel for how MPS works. And finally, I will point you to things you can read to get you started with your own language development practice.
Après la présentation de #Flutter, Julien nous révèle toute la puissance de #Go, encore un autre langage de programmation créé par Google.
After the #Flutter presentation, Julien reveals all the power of #Go, yet another programming language created by Google.
Following on from the success of last year, this annual event for London's architect community will have architectural innovation as a theme this year, and particularly CQRS. At the DDD eXchange we will feature leading thinkers and architects who will share their experience and Eric Evans is the programme lead.
Graphic and interaction design are two fields critical to software development that — unlike code have — have not yet nourished a successful collaboration model. What can we learn from the Wordpress community’s latest attempts to involve designers in the open source process? Can we simply apply the same collaboration methods from code to design? And what other examples and models are available for us to borrow from? What are the challenges of networked collaboration in the creative process? Can they and how might they be solved? Or is it just that designers don’t like to work together? Mushon will be presenting and leading a discussion on the subject with examples from the Wordpress community, his own work, and the research done in his Open Source Design class taught in Parsons’ AAS Program in Graphic Design. Speaker: Mushon Zer-Aviv.
More on http://mushon.com
5 things cucumber is bad at by Richard LawrenceSkills Matter
This talk will look at 5 things Cucumber’s bad at, why that’s a good thing, and what it tells us about Cucumber’s sweet spot in a team’s toolkit.
Many times, when people complain about something Cucumber’s not good at, they’re unwittingly describing something Cucumber shouldn't be good at. They’re revealing that they don’t quite understand BDD and Cucumber’s role in it.
Cucumber is the world's most misunderstood collaboration tool and people need to hear this over and over again.
Patterns for slick database applicationsSkills Matter
Slick is Typesafe's open source database access library for Scala. It features a collection-style API, compact syntax, type-safe, compositional queries and explicit execution control. Community feedback helped us to identify common problems developers are facing when writing Slick applications. This talk suggests particular solutions to these problems. We will be looking at reducing boiler-plate, re-using code between queries, efficiently modeling object references and more.
Scala e xchange 2013 haoyi li on metascala a tiny diy jvmSkills Matter
Metascala is a tiny metacircular Java Virtual Machine (JVM) written in the Scala programming language. Metascala is barely 3000 lines of Scala, and is complete enough that it is able to interpret itself metacircularly. Being written in Scala and compiled to Java bytecode, the Metascala JVM requires a host JVM in order to run.
The goal of Metascala is to create a platform to experiment with the JVM: a 3000 line JVM written in Scala is probably much more approachable than the 1,000,000 lines of C/C++ which make up HotSpot, the standard implementation, and more amenable to implementing fun features like continuations, isolates or value classes. The 3000 lines of code gives you:
The bytecode interpreter, together with all the run-time data structures
A stack-machine to SSA register-machine bytecode translator
A custom heap, complete with a stop-the-world, copying garbage collector
Implementations of parts of the JVM's native interface
Although it is far from a complete implementation, Metascala already provides the ability to run untrusted bytecode securely (albeit slowly), since every operation which could potentially cause harm (including memory allocations and CPU usage) is virtualized and can be controlled. Ongoing work includes tightening of the security guarantees, improving compatibility and increasing performance.
ENJOYIN
Progressive f# tutorials nyc dmitry mozorov & jack pappas on code quotations ...Skills Matter
Code Quotations: Code-as-Data for F#
This tutorial will cover F# Code Quotations in-depth. You'll learn what Code Quotations are, how to use them, and where to apply them in your applications. We'll work through several real-world examples to highlight the important features -- and potential pitfalls -- of Code Quotations.
Cukeup nyc ian dees on elixir, erlang, and cucumberlSkills Matter
Elixir, Erlang, and Cucumberl
Elixir is a new Ruby-inspired programming language that uses the powerful concurrent machinery of Erlang behind the scenes. Cucumberl is a port of Cucumber to Erlang. Let's see what happens when we put them together.
In this talk, we'll discuss:
How Erlang's concurrency makes it easier to write robust programs
Elixir's approachable syntax
How to test Erlang and Elixir programs using Cucumberl
Attendees will walk away with a solid introduction to the principles of Erlang, and an appreciation of the way Elixir brings the joy of Ruby to the solidity of the Erlang runtime.
Cukeup nyc peter bell on getting started with cucumber.jsSkills Matter
Cukeup NYC. Peter Bell on Getting started with cucumber.js
Ever wished you could use cucumber in your javascript apps? In this talk we'll look at the current state of play of cucumber js, when you should and shouldn't use it, and how to get started writing your step definitions in javascript.
Agile testing & bdd e xchange nyc 2013 jeffrey davidson & lav pathak & sam ho...Skills Matter
In this engaging experience report, we will present 3 different views – Developer, Tester, Business Analyst – of implementing Acceptance Test Driven Development in a complex, data-driven domain. Hear how we used ATDD for building a ubiquitous language across the entire team, promoting faster feedback, and cultivating a culture where product owners were deeply invested in the quality of both every deliverable and the system as a whole.
Progressive f# tutorials nyc rachel reese & phil trelford on try f# from zero...Skills Matter
In this tutorial, Phil and Rachel will introduce you to the Try F# samples giving you exposure to, and an understanding of, how F# tackles some real-world scenarios. We'll help you explore, generate, and just play around with code samples, as well as talk you through some of the key principles of F#. By the end of this session, you'll have gone from zero to data science in only a few hours!
Progressive f# tutorials nyc don syme on keynote f# in the open source worldSkills Matter
F# is a powerful open-source language which Microsoft, other companies and the F# community all contribute to. In this talk, Don will discuss how the “F# space” has recently opened up significantly in interesting ways. F# now includes contributions that range from Cloud IDE platforms, Cloud Compute frameworks, Data interoperability components, Cross-platform execution, Try F#, MonoDevelop, and even Emacs editor integration with surprising tooling support, as well as the Visual F# tools from Microsoft and the broader NuGet package ecosystem. Don will also talk about some of the latest contributions from Microsoft Research, including new type provider components for F#, and describe how his team work with the Visual F# team and other teams around Microsoft. There will also be demos of some fun new stuff that’s been going on with F# at MSR and the community.
Agile testing & bdd e xchange nyc 2013 gojko adzic on bond villain guide to s...Skills Matter
Would you like to learn how to make your software testing practices more effective? And how to use your testing strategy to better capture and reflect customer requirements? Gojko Adzic takes a critical look at the effectiveness of current software testing practices and proposes strategies to make it much more effective.
Dmitry mozorov on code quotations code as-data for f#Skills Matter
Code Quotations: Code-as-Data for F#
This tutorial will cover F# Code Quotations in-depth. You'll learn what Code Quotations are, how to use them, and where to apply them in your applications. We'll work through several real-world examples to highlight the important features -- and potential pitfalls -- of Code Quotations.
Simon Peyton Jones: Managing parallelismSkills Matter
If you want to program a parallel computer, it obviously makes sense to start with a computational paradigm in which parallelism is the default (ie functional programming), rather than one in which computation is based on sequential flow of control (the imperative paradigm). And yet, and yet ... functional programmers have been singing this tune since the 1980s, but do not yet rule the world. In this talk I’ll say why I think parallelism is too complex a beast to be slain at one blow, and how we are going to be driven, willy-nilly, towards a world in which side effects are much more tightly controlled than now. I’ll sketch a whole range of ways of writing parallel program in a functional paradigm (implicit parallelism, transactional memory, data parallelism, DSLs for GPUs, distributed processes, etc, etc), illustrating with examples from the rapidly moving Haskell community, and identifying some of the challenges we need to tackle.
DevOps and Testing slides at DASA ConnectKari Kakkonen
My and Rik Marselis slides at 30.5.2024 DASA Connect conference. We discuss about what is testing, then what is agile testing and finally what is Testing in DevOps. Finally we had lovely workshop with the participants trying to find out different ways to think about quality and testing in different parts of the DevOps infinity loop.
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
Kubernetes & AI - Beauty and the Beast !?! @KCD Istanbul 2024Tobias Schneck
As AI technology is pushing into IT I was wondering myself, as an “infrastructure container kubernetes guy”, how get this fancy AI technology get managed from an infrastructure operational view? Is it possible to apply our lovely cloud native principals as well? What benefit’s both technologies could bring to each other?
Let me take this questions and provide you a short journey through existing deployment models and use cases for AI software. On practical examples, we discuss what cloud/on-premise strategy we may need for applying it to our own infrastructure to get it to work from an enterprise perspective. I want to give an overview about infrastructure requirements and technologies, what could be beneficial or limiting your AI use cases in an enterprise environment. An interactive Demo will give you some insides, what approaches I got already working for real.
UiPath Test Automation using UiPath Test Suite series, part 3DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 3. In this session, we will cover desktop automation along with UI automation.
Topics covered:
UI automation Introduction,
UI automation Sample
Desktop automation flow
Pradeep Chinnala, Senior Consultant Automation Developer @WonderBotz and UiPath MVP
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Transcript: Selling digital books in 2024: Insights from industry leaders - T...BookNet Canada
The publishing industry has been selling digital audiobooks and ebooks for over a decade and has found its groove. What’s changed? What has stayed the same? Where do we go from here? Join a group of leading sales peers from across the industry for a conversation about the lessons learned since the popularization of digital books, best practices, digital book supply chain management, and more.
Link to video recording: https://bnctechforum.ca/sessions/selling-digital-books-in-2024-insights-from-industry-leaders/
Presented by BookNet Canada on May 28, 2024, with support from the Department of Canadian Heritage.
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
Accelerate your Kubernetes clusters with Varnish CachingThijs Feryn
A presentation about the usage and availability of Varnish on Kubernetes. This talk explores the capabilities of Varnish caching and shows how to use the Varnish Helm chart to deploy it to Kubernetes.
This presentation was delivered at K8SUG Singapore. See https://feryn.eu/presentations/accelerate-your-kubernetes-clusters-with-varnish-caching-k8sug-singapore-28-2024 for more details.
Builder.ai Founder Sachin Dev Duggal's Strategic Approach to Create an Innova...Ramesh Iyer
In today's fast-changing business world, Companies that adapt and embrace new ideas often need help to keep up with the competition. However, fostering a culture of innovation takes much work. It takes vision, leadership and willingness to take risks in the right proportion. Sachin Dev Duggal, co-founder of Builder.ai, has perfected the art of this balance, creating a company culture where creativity and growth are nurtured at each stage.
Slack (or Teams) Automation for Bonterra Impact Management (fka Social Soluti...Jeffrey Haguewood
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on the notifications, alerts, and approval requests using Slack for Bonterra Impact Management. The solutions covered in this webinar can also be deployed for Microsoft Teams.
Interested in deploying notification automations for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
Essentials of Automations: Optimizing FME Workflows with ParametersSafe Software
Are you looking to streamline your workflows and boost your projects’ efficiency? Do you find yourself searching for ways to add flexibility and control over your FME workflows? If so, you’re in the right place.
Join us for an insightful dive into the world of FME parameters, a critical element in optimizing workflow efficiency. This webinar marks the beginning of our three-part “Essentials of Automation” series. This first webinar is designed to equip you with the knowledge and skills to utilize parameters effectively: enhancing the flexibility, maintainability, and user control of your FME projects.
Here’s what you’ll gain:
- Essentials of FME Parameters: Understand the pivotal role of parameters, including Reader/Writer, Transformer, User, and FME Flow categories. Discover how they are the key to unlocking automation and optimization within your workflows.
- Practical Applications in FME Form: Delve into key user parameter types including choice, connections, and file URLs. Allow users to control how a workflow runs, making your workflows more reusable. Learn to import values and deliver the best user experience for your workflows while enhancing accuracy.
- Optimization Strategies in FME Flow: Explore the creation and strategic deployment of parameters in FME Flow, including the use of deployment and geometry parameters, to maximize workflow efficiency.
- Pro Tips for Success: Gain insights on parameterizing connections and leveraging new features like Conditional Visibility for clarity and simplicity.
We’ll wrap up with a glimpse into future webinars, followed by a Q&A session to address your specific questions surrounding this topic.
Don’t miss this opportunity to elevate your FME expertise and drive your projects to new heights of efficiency.
Software Delivery At the Speed of AI: Inflectra Invests In AI-Powered QualityInflectra
In this insightful webinar, Inflectra explores how artificial intelligence (AI) is transforming software development and testing. Discover how AI-powered tools are revolutionizing every stage of the software development lifecycle (SDLC), from design and prototyping to testing, deployment, and monitoring.
Learn about:
• The Future of Testing: How AI is shifting testing towards verification, analysis, and higher-level skills, while reducing repetitive tasks.
• Test Automation: How AI-powered test case generation, optimization, and self-healing tests are making testing more efficient and effective.
• Visual Testing: Explore the emerging capabilities of AI in visual testing and how it's set to revolutionize UI verification.
• Inflectra's AI Solutions: See demonstrations of Inflectra's cutting-edge AI tools like the ChatGPT plugin and Azure Open AI platform, designed to streamline your testing process.
Whether you're a developer, tester, or QA professional, this webinar will give you valuable insights into how AI is shaping the future of software delivery.
5. Aren’t Jargons Bad?
They’re very bad for people who don’t understand
the domain or don’t share the context
You’d be totally lost
But, they’re very good for people who share the
context in the domain
The communication is highly effective
Terse, high signal—to—noise ratio
This is what professionals use in their respective
fields
5
6. How do you use your App/
Computer?
Typically you use keyword
input files, configuration
files, etc.
If you’re stuck at an
airport, which of these two
agents gives you the most
confidence you’ll be on your
way—one that uses the
keyboard, or the one that
mouses around?
The former, uses direct
queries 6
7. Productivity is Key
A GUI makes an average
user productive, but often
may slowdown an expert
user or a user very fluent
with your application and
its domain.
You don't want to make the
novice productive at the
expense of making an
expert counterproductive.
7
8. Naked Objects
Richard Pawson and Robert
Matthews introduced the
concept of Naked Objects
They auto-build a thin
object-oriented user
interface (OOUI) from a
domain model
The OOUI exposes the
behavior of domain objects
for direct interaction by
the users.
8
9. How does an expert express
Matrix Multiplication?
9
10. Goal of a DSL
The goal of DSLs is to provide a highly effective
interface for your users to interact with your
application.
The interface may be graphical or textual.
10
12. Domain Specific Language
A language targeted at a particular type of
problem
Syntax focuses on intended domain/problem
Unlike a general purpose language, you can’t use it
for all kinds of stuff (or don’t want to)
Limited in scope and capability
Hence, they’re small and simple—that’s good
12
13. Domain and Context
What’s Domain?
It is an area of sphere or
knowledge, influence, or activity
What’s Context?
A logical framework within which
we evolve models
What’s Bounded Context?
Context
Defines a logical boundary of
relevance within the context
Domain
13
14. What is it really?
It’s a ubiquitous language—only
narrow within a domain
Domain folks understand it well
Highly expressive and easy to
use
14
15. Where does it fit?
You’re most likely to use multiple languages to build
your application—Neal Ford’s vision for Polyglot
Programmer.
Martin Fowler argues that rather than using one big
general purpose language, applications will use
several small and limited DSLs—Languages Oriented
Programming.
Ola Bini argues at http://ola-bini.blogspot.com/
2008/01/language-explorations.html that "three
language layers will emerge in large applications"
15
16. Where does it fit?
Ola’s Pyramid
Expressive
Domain Specific DSL
Layer
Groovy/ Dynamic Layer
JRuby (Most Functionality)
Java/Scala/
JVM Small Stable Layer
16
17. What’s Need to Build ‘em?
Objects + Meta Programming (Aspects) + lots of
Patience +
17
19. External DSL
You define a new language
You then parse the commands to take actions
You have the liberty to chose the syntax you like
You’re in full control—that’s good... and bad
Can be lot of fun ;)
One of my first jobs was to maintain lex and Yacc...
19
23. Internal DSL
Also known as Embedded DSLs
Built on top of a host language
Constructs of your host language are construed to form a
DSL
You don’t need to write an separate parser—that’s less work
Commands tactfully map over to constructs like methods, etc.
You can enjoy the host language’s flexibility, but you get
bitten by its limitations and idiosyncrasies
23
26. Internal DSL Examples
easyb is an example of internal DSL
It is a Behavior Driven Design Tool and uses Groovy
for expressing stories and behavior in a DSL form
26
27. External or Internal
It depends on your application
Certain (dynamic) languages are better suited for
internal DSLs
Smalltalk, Lisp, Ruby, Groovy, ...
Other languages are better suited for external DSL
and offer good parsing libraries or capabilities
C++, Java, C#, ...
27
28. External or Internal
External Internal
+You decide syntax - You decide within
limits of host language
-You write parser for + Language takes care
it of parsing
+ A tad easier to - You gotta find your
design way around host
+ Once you write a - Hard to validate at
parser, validation is a the moment, good
breeze research potential
28
29. Are all Languages Suited for
Not really Internal DSLs?
Low Ceremony + Metaprogramming is essential
Scala, for example, has low ceremony, but lacks
metaprogramming capabilities. So, not so easy to write
internal DSLs with it
Groovy, Ruby, ... shine due to high essence, low
ceremony, and metaprogramming
29
30. Characteristics of a DSL
What are some of the qualities of a DSL?
Context Driven
Extremely context sensitive
Fluent Interfaces
Provides for a humane, easy to understand
interface
30
31. Context Driven
DSL is extremely context sensitive or context driven
A lot of things are knows from the context
Without context, we may be confused or misled
With context, there is less clutter, terse, but
readable
31
32. Context Driven ...
I heard my friend Neal Ford yell out
Quad Venti Latte with 2 Extra Shots
What’s he talking about?
He’s using the Starbucks DSL
Nowhere did he mention the word coffee, but he sure
got a good one at a high price ;)
That’s context driven
32
33. Context Driven ...
I heard my friend Scott Davis mutter
place a $ in a GString
What’s he talking about?
You don’t want to know
He sure was talking about embedding variables into
the Groovy’s mutable string class
That’s also context driven :)
33
34. Fluent Interface
I was going to call this hygienic interface
I like the name Eric Evans and Martin Fowler
promote–Fluent Interface/Humane Interface
It’s designed to be readable and to flow naturally
Not easy to design–you put in more effort to create
it, so it is easier for users to use
34
35. Code With No Context
What do you do with mailer object after call to send?
Is the order important?
Do I have to create an object each time?
...
Can I just get my work done, can this be simpler?
35
40. How to get Fluency?
You can achieve fluency in Java as well
You can use method chaining with a little
compromise
40
41. A Little Compromise
Command Query Separation was promoted by
Bertrand Meyer
Command methods—mutators or modifiers—affect
object state and don’t return anything
Query methods—don’t affect object state and
return useful information
You compromise a little to be fluent (kind of like
words bent to rhyme in a poem)
Command methods return self or a promoter for a
good flow
41
47. Let’s Order Pizza
Voice on line (VOL): Thanks for calling Joe’s
You: Ya, A Large Thin Crust
VOL: Toppings?
You: Olives, Onions, Bell Pepper
VOL: Address
You: 101 Main St.,...
VOL: Card?
You: Visa 1234-1234-1234-1234
VOL: 20 minutes–Thank you 47
48. Java Pizza Order
Not fluent
Very noisy—how many times do you have to say
joes_pizza?
Can we make it fluent?
48
49. with
Some languages have a with keyword
within the scope, methods are invoked on an
implicit object
Here is an example from JavaScript
49
51. How about Fluent Java?
Less clutter
There is a context in each call
Each set method (except setCard()) returns this
(PizzaShop)
Can we make this a bit more readable?
51
52. A bit more Fluent...
Method names make sense in the flow, but may
not make sense alone
What’s a catch?
52
53. Ordered vs. Unordered
Some DSLs may require a certain order in the
flow
You can force ordering by tactfully defining
return types that will allow method chaining in
only certain order
Not easy
Others may not require ordering
It depends on the particular problem
Ideally, not requiring an order is great, but may
not always be possible
53
56. OK, but...
You may not be able to deviate from standard API
conventions
What if it is existing API or there are other reasons
to follow conventions?
You can use a Façade or expression builder
It sits on top of existing traditional API and
provides context and fluency
For example, Groovy has a number of these
builders built-in
56
59. Creating DSLs
You may use tools like Antlr for working with DSLs
JetBrains is working on Meta Programming
System(MPS)
Languages like Ruby and Groovy may it easier to
create (internal) DSLs
What makes Groovy attractive?
Classes are always open
Closures and Builders
Categories and ExpandoMetaClass
To some extent operator overloading
59
Parenthesis are almost optional (a bit lacking)
60. Creating a DSL in Groovy
file:order
See next page
file:process.groovy
output
60
61. Creating a DSL in Groovy
contents of file:defs.groovy
methodMissing
61
62. transmogrification
How to deal with
fluency, context, and
ordering
You can tactfully
return different
interfaces so only
correct sequence of
calls will fit in
Return an appropriate
interface from your
methods and let
method chaining take
over
62
66. Categories vs.
ExpandoMetaClass
Categories allows you to tactically enhance a class
ExpandoMetaClass is far reaching, global in nature
You may not want to affect a class globally
Categories provide controlled flexibility
66
67. Run Your DSL within a Context
Running your DSL out in the open is not good:
Unpredictable, unsettling
Run it within the context of an object
67
68. Running in a context
scores
See next page
Output
68
72. References
A number of references from the following URL
http://martinfowler.com/bliki/DomainSpecificLanguage.html
http://docs.codehaus.org/display/GROOVY/Writing+Domain-Specific
+Languages
http://docs.codehaus.org/display/GROOVY/Gant
http://groovy.codehaus.org/ExpandoMetaClass
http://www.onboard.jetbrains.com/is1/articles/04/10/lop/
http://www.jetbrains.com/mps
You can download examples and slides from
http://www.agiledeveloper.com - download 72
73. Thank You!
Please fill in your session evaluations
You can download examples and slides from
http://www.agiledeveloper.com - download 73