Of Rats And Dragons

•

0 recomendaciones•793 vistas

Reviews grammar and parsers and discusses my personal path toward writing my own packrat parser-generator for Erlang called neotoma. Given to "Evil Robot Conference" on September 12, 2009.

Tecnología

Of Rats And
Dragons
Achieving Parsing Sanity

Sean Cribbs

Web Consultant
Ruby and Erlang Hacker

Saturday, September 12, 2009

Quick Review
Saturday, September 12, 2009

context-free
grammars

Saturday, September 12, 2009

G = (V, Σ, R, S)

Saturday, September 12, 2009

non-deterministic
pushdown
automata

Saturday, September 12, 2009

stack machine
w/ backtracking

Saturday, September 12, 2009

massage it

Saturday, September 12, 2009

ε productions

Saturday, September 12, 2009

produce nothing
never produced

Saturday, September 12, 2009

ambiguities
“dangling else”

Saturday, September 12, 2009

if A then if B then C else D

if A then if B then C else D

if A then if B then C else D

Saturday, September 12, 2009

parsing expression
grammars

Saturday, September 12, 2009

top-down parsing
language (70’s)

Saturday, September 12, 2009

direct
representation of
parsing functions

Saturday, September 12, 2009

Brian Ford 2002

Saturday, September 12, 2009

focused on
recognizing

Saturday, September 12, 2009

computer
languages

Saturday, September 12, 2009

“string”
.

Saturday, September 12, 2009

PEG > regexps

Saturday, September 12, 2009

combined
lex+parse

Saturday, September 12, 2009

no ambiguity

Saturday, September 12, 2009

choice is ordered

Saturday, September 12, 2009

dangling else
obviated

Saturday, September 12, 2009

greedy repetition

Saturday, September 12, 2009

unlimited
lookahead
with predicates

Saturday, September 12, 2009

no left-recursion!
(use *,+)

Saturday, September 12, 2009

Parsing
Techniques

Saturday, September 12, 2009

Tabular
test every rule

Saturday, September 12, 2009

Recursive-descent
call & consume

Saturday, September 12, 2009

Predictive
yacc/yecc

Saturday, September 12, 2009

Packrat
RD with memo

Saturday, September 12, 2009

sacriﬁce memory
for speed

Saturday, September 12, 2009

supports PEGs and
some CFGs

Saturday, September 12, 2009

Treetop
Pappy
neotoma

Saturday, September 12, 2009

neotoma
Behind the CodeTM

Saturday, September 12, 2009

can:has(cukes) ->
false.

Saturday, September 12, 2009

Cucumber uses
Treetop

Saturday, September 12, 2009

PEG → leex/yecc
FAIL

Saturday, September 12, 2009

parsec → eParSec

Saturday, September 12, 2009

HOF protocol

Saturday, September 12, 2009

$% Implements "?" PEG operator optional(P) -> fun(Input, Index) -> case P(Input, Index) of {fail, _} -> {[], Input, Index}; {_,_,_} = Success -> Success % {Parsed, RemainingInput, NewIndex} end end. Saturday, September 12, 2009$

% PEG
optional_space <- space?;

% Erlang
optional_space(Input,Index) ->
optional(fun space/2)(Input, Index).

Saturday, September 12, 2009

Yay! RD!
make it memo

Saturday, September 12, 2009

ets
Erlang Term
Storage

Saturday, September 12, 2009

{key, value}

Saturday, September 12, 2009

key = Index

Saturday, September 12, 2009

value = dict

Saturday, September 12, 2009

$% Memoization wrapper p(Inp, StartIndex, Name, ParseFun, TransformFun) -> % Grab the memo table from ets Memo = get_memo(StartIndex), % See if the current reduction is memoized case dict:find(Name, Memo) of % If it is, return the result {ok, Result} -> Result; % If not, attempt to parse _ -> case ParseFun(Inp, StartIndex) of % If it fails, memoize the failure {fail,_} = Failure -> memoize(StartIndex, dict:store(Name, Failure, Memo)), Failure; % If it passes, transform and memoize the result. {Result, InpRem, NewIndex} -> Transformed = TransformFun(Result, StartIndex), memoize(StartIndex, dict:store(Name, {Transformed, InpRem, NewIndex}, Memo)), {Transformed, InpRem, NewIndex} end end. Saturday, September 12, 2009$

parse_transform

Saturday, September 12, 2009

alternative(Input, Index) ->
peg:p(Input, Index, alternative, fun(I,P) ->
peg:choose([fun sequence/2, fun primary/2])(I,P)
end).

rule(alternative) ->
peg:choose([fun sequence/2, fun primary/2]);

Saturday, September 12, 2009

rules <- space? declaration_sequence space?;
declaration_sequence <- head:declaration tail:(space declaration)*;
declaration <- nonterminal space '<-' space parsing_expression space? ';';
parsing_expression <- choice / sequence / primary;
choice <- head:alternative tail:(space '/' space alternative)+;
alternative <- sequence / primary;
primary <- prefix atomic / atomic suffix / atomic;
sequence <- head:labeled_sequence_primary tail:(space labeled_sequence_primary)+;
labeled_sequence_primary <- label? primary;
label <- alpha_char alphanumeric_char* ':';
suffix <- repetition_suffix / optional_suffix;
optional_suffix <- '?';
repetition_suffix <- '+' / '*';
prefix <- '&' / '!';
atomic <- terminal / nonterminal / parenthesized_expression;
parenthesized_expression <- '(' space? parsing_expression space? ')';
nonterminal <- alpha_char alphanumeric_char*;
terminal <- quoted_string / character_class / anything_symbol;
quoted_string <- single_quoted_string / double_quoted_string;
double_quoted_string <- '"' string:(!'"' ("" / '"' / .))* '"';
single_quoted_string <- "'" string:(!"'" ("" / "'" / .))* "'";
character_class <- '[' characters:(!']' ('' . / !'' .))+ ']
anything_symbol <- '.';
alpha_char <- [a-z_];
alphanumeric_char <- alpha_char / [0-9];
space <- (white / comment_to_eol)+;
comment_to_eol <- '%' (!"n" .)*;
white <- [ tnr];

Saturday, September 12, 2009

self-hosting

Saturday, September 12, 2009

Future directions

Saturday, September 12, 2009

self-contained
parsers

Saturday, September 12, 2009

inline code in PEG

Saturday, September 12, 2009

Reia
retem
sedate

Saturday, September 12, 2009

questions?

Saturday, September 12, 2009

Más contenido relacionado

Destacado

Ftp

Hover Ige

Income statement

One direction

Utfordringer ved interhospital intensivtransport i Norge

Helge Eiding

French Revolution Comic

drloewen

Microsoft Learning Experiences Skills and Employability

Lee Stott

Smart Student Tracking System for Schools and Parents from CodeLand

Sachidanand Bhat

The oversampling recruitment is a limiting factor in high frequency application such as software defined radio. This project is a high frequency processing and low oversampling ratio. A single bit semi parallel processing is proposed in this paper. Using this single bit PDSM Architecture, high speed, high complexity computations are executed in parallel. The single bit DSM is to build an RF transmitter that includes a one bit quantifier with two level switching power amplifier for high linearity and high efficiency. Performance analysis by using the MATLAB simulations by reducing the oversampling ratio by same signal to noise ratio. The DSM implemented on field programmable gate array and using a signal code division multiple access signal. This project will give bandwidth of the low oversampled signal increased four times without increasing frequency. Finally they can be achieved signal to noise ratio is very low and also oversampling ratio is small.

DSM Based low oversampling using SDR transmitter

IJTET Journal

Computadora (tecnologia)

Brendadeprada

Practica 20 mayo 2016

Luis López

2015-CV-Marina-Micic-V2

Marina Micik

Arabic script is one of the most widely used scripts in the world. Besides 340 millions native speakers, more than 200 million nonnative speakers are there in the world. Many languages such as Urdu, Persian, etc. adopted this script. Therefore, recognition of optical handwritten Arabic characters has received significant attention from the past decade. Unlike numerals of any other scripts, some Arabic numerals have more than one representation. For instance, Arabic ‘4’, ‘5’ and ‘7’ have two variations each. Considering these variants as the same class may deviate the recognition performance. The present work proposed a mechanism to deal with such variations for improved classification. At the first phase, the recognition problem is considered as a 13 class classification problem instead of 10. Then, in the second phase, the classes are reorganized and post-processed for improved classification. A comparative study has also been included with the conventional approach that considers the variants as the same class. Experimental results reflect the efficiency of the proposed technique.

Recognition of Isolated Handwritten Arabic and Urdu Numerals along with their...

Association of Scientists, Developers and Faculties

Colegio El Rosario 2016 -Partido seleccion y maestros

Luis López

Lessening in test force is vital to enhance battery lifetime in versatile electronic gadgets utilizing intermittent individual test. It's to expand dependability of testing, and to lessen test expense. A conservative test set with exceedingly viable examples, every identifying different issues, is attractive for lower test expenses. Such examples build exchanging action amid dispatch and catch operations. In this paper, we exhibit a novel circuit strategy to essentially dispense with test force dissemination in combinational logic by veiling sign moves at the logic inputs amid sweep moving is exhibited. We execute the concealing impact by embeddings an additional supply gating transistor in the supply to ground way for the first-level doors at the yields of the output flip-flops. The gating transistor supply is killed in the output in mode, basically gating the supply. Further, DFT punishments are decreased by embracing specific trigger Scan structural planning. This building design diminishes exchanging action in the circuit-under-test (CUT) and builds the clock recurrence of the checking methodology. The assistant chain moves in the contrast between sequential test vectors and just the obliged moves (alluded to as trigger information) are connected. Power necessities are significantly decreased by the utilization of a two-stage heuristic technique. Utilizing ISCAS 89 benchmark circuits, this adequacy is to enhance SoC test measures (power, time, and information volume) is tentatively assessed and affirmed.

Techniques for Minimizing Power Consumption in DFT during Scan Test Activity

IJTET Journal

Project management overview

LineView Academy (was OFX Academy)

Destacado (16)

Ftp

Hover Ige

Income statement

One direction

Utfordringer ved interhospital intensivtransport i Norge

French Revolution Comic

Microsoft Learning Experiences Skills and Employability

Smart Student Tracking System for Schools and Parents from CodeLand

DSM Based low oversampling using SDR transmitter

Computadora (tecnologia)

Practica 20 mayo 2016

2015-CV-Marina-Micic-V2

Recognition of Isolated Handwritten Arabic and Urdu Numerals along with their...

Colegio El Rosario 2016 -Partido seleccion y maestros

Techniques for Minimizing Power Consumption in DFT during Scan Test Activity

Project management overview

Similar a Of Rats And Dragons

DelveUI Slides

jkosoy

2011 NOTE: Some links in this presentation are no longer valid. Sorry about that. As a professional developer, especially one who works in Ruby, you hear about code quality all the time. You learn that testing your code and making it easy to maintain are the path to success. You know about TDD, BDD, TATFT and LMNOP. You learn to cycle from red to green to refactoring. We all do our best to write quality, maintainable, reusable code. We're all human, though; some of us slip, and some of us have had to work hard at preventing code smells. In this talk, I'll talk about how I learned to program, how going pro exposed flaws in my coding style, and how I'm working to improve my code quality, sharing some of my old stinky code, the better, refactored versions, and the lessons I've learned in honing my craft.

Code Stinkers Anonymous

Mark Cornick

This slide set was used in job-embedded professional development on 09.09.09 and is designed to give a brief overview of many Google features. These features all have at least some application in the world of public education. Although this slide set does not address Google apps for education, (and barely grazes Google Docs) it does provide a glimpse into the creative engine that is Google. How can these feature sets be used within your classroom?

Google in Education (just a peek)

North Kansas City Schools

Building A Framework On Rack

Matt Todd

Semcomp de São Carlos

Fabio Akita

Software livre e padrões abertos no desenvolvimento Web

Felipe Ribeiro

Its all about collaboration

Richard Wallis

Localizing iOS Apps

weissazool

100% JS

__lucas

Latinoware Rails 2009

Fabio Akita

Expand to or work in China and Germany

Daniel Bovensiepen

TRNK Presentation

Dennis Reumer

Zeno rocha - HTML5 APIs para Mobile

iMasters

Mobile Approaches - LinguÁgil 2012

Pedro E. Cunha Brigatto

Spring in-the-cloud

Joshua Long

06 Data

Hadley Wickham

2009, o ano do Ruby on Rails no Brasil - CaelumDay 2009

Caue Guerra

The Beauty of Bootstrapping - Doing it Anyway

Chris Schultz

Kostentreiber bei der iOS-Entwicklung

xrb

Kostentreiber bei der iOS Entwicklung

Reto Zenger

Similar a Of Rats And Dragons (20)

DelveUI Slides

Code Stinkers Anonymous

Google in Education (just a peek)

Building A Framework On Rack

Semcomp de São Carlos

Software livre e padrões abertos no desenvolvimento Web

Its all about collaboration

Localizing iOS Apps

100% JS

Latinoware Rails 2009

Expand to or work in China and Germany

TRNK Presentation

Zeno rocha - HTML5 APIs para Mobile

Mobile Approaches - LinguÁgil 2012

Spring in-the-cloud

06 Data

2009, o ano do Ruby on Rails no Brasil - CaelumDay 2009

The Beauty of Bootstrapping - Doing it Anyway

Kostentreiber bei der iOS-Entwicklung

Kostentreiber bei der iOS Entwicklung

Más de Sean Cribbs

There are many reasons to use an eventually-consistent database — like Riak, Voldemort, or Cassandra — including increased availability, lower latency, and fault-tolerance. However, doing so requires a mental shift in how to structure client applications, and certain types of traditional data-structures, like sets, registers, and counters can’t be resolved simply in the face of race-conditions. It is difficult to achieve “logical monotonicity” except for the most trivial data-types. That is, until the advent of Convergent Replicated Data Types (CRDTs). CRDTs are data-structures that tolerate eventual consistency. They replace traditional data-structure implementations and all have the property that, given any number of conflicting versions of the same datum, there is a single state on which they converge (monotonicity). This talk will discuss some of the most useful CRDTs and how to apply them to solve real-world data problems.

Eventually Consistent Data Structures (from strangeloop12)

Sean Cribbs

There are many reasons to use an eventually-consistent database -- like Riak, Voldemort, or Cassandra -- including increased availability, lower latency, and fault-tolerance. However, doing so requires a mental shift in how to structure client applications, and certain types of traditional data-structures, like sets, registers, and counters can't be resolved simply in the face of race-conditions. It is difficult to achieve "logical monotonicity" except for the most trivial data-types. That is, until the advent of Conflict-Free Replicated Data Types (CRDTs). CRDTs are data-structures that tolerate eventual consistency. They replace traditional data-structure implementations and all have the property that, given any number of conflicting versions of the same datum, there is a single state on which they converge (monotonicity). This talk will discuss some of the most useful CRDTs and how to apply them to solve real-world data problems.

Eventually-Consistent Data Structures

Sean Cribbs

Concurrency in Ruby is all the rage these days, and people can't seem to agree whether Threads, Fibers, event loops, or actors are the best solution. But did you ever consider that your *sequential* Ruby program might be concurrent, with nary a Thread, Fiber, or callback in sight? Well, it happened to me. This is the story of how accidental concurrency (also known as re-entrancy) broke my brain multiple times over the course of two years, spawned flamewars on Twitter, long blog posts, and the various solutions I took to solve the problem. Along the way we'll illuminate some subtleties of concurrent programming in Ruby, differences between several Ruby implementations, and how we can all write code that is friendlier when accidental concurrency strikes.

A Case of Accidental Concurrency

Sean Cribbs

So, there's this "NoSQL" thing you may have heard of, and this related thing called "eventual consistency". Supposedly, they help you scale, but no one has ever explained why! Well, wonder no more! This talk will demystify NoSQL, eventual consistency, how they might help you scale, and -- most importantly -- why you should care. We'll look closely at how Riak, a linearly-scalable, distributed and fault-tolerant NoSQL datastore, implements eventual consistency, and how you can harness it from Ruby via the slick Ripple client/ORM. When the talk is finished, you'll have the tools both to understand eventual consistency and to handle it like a pro inside your next Ruby application.

Embrace NoSQL and Eventual Consistency with Ripple

Sean Cribbs

Riak with node.js

Sean Cribbs

Schema Design for Riak (Take 2)

Sean Cribbs

Riak (Øredev nosql day)

Sean Cribbs

Riak Tutorial (Øredev)

Sean Cribbs

The Radiant Ethic

Sean Cribbs

Introduction to Riak and Ripple (KC.rb)

Sean Cribbs

Riak with Rails

Sean Cribbs

Schema Design for Riak

Sean Cribbs

Introduction to Riak - Red Dirt Ruby Conf Training

Sean Cribbs

Introducing Riak and Ripple

Sean Cribbs

Many developers will be familiar with lex, flex, yacc, bison, ANTLR, and other related tools to generate parsers for use inside their own code. For recognizing computer-friendly languages, however, context-free grammars and their parser-generators leave a few things to be desired. This is about how the seemingly simple prospect of parsing some text turned into a new parser toolkit for Erlang, and why functional programming makes parsing fun and awesome

Round PEG, Round Hole - Parsing Functionally

Sean Cribbs

Software projects are rarely on-spec, on-time and on-budget, and the primary cause is miscommunication. As Martin Fowler says, there is a "yawning crevasse of doom" between stakeholders and developers, full of misunderstanding. How do you make sure that you're building something that adds value? How do you know you're building the thing that was asked for? How does your bottom line affect user experience? Into the fray leaps Cucumber, a business-readable DSL combined with an awesome Ruby library that lets domain experts express business requirements as executable user stories. We'll cover outside-in, story-driven development with Cucumber, how to write effective stories, and how to make Cucumber work for your project. (as given to CharlotteRuby on Jan 6, 2010)

Story Driven Development With Cucumber

Sean Cribbs

Most developers will be familiar with lex, flex, yacc, bison, ANTLR, and other tools to generate parsers for use inside their own code. Erlang, the concurrent functional programming language, has its own pair, leex and yecc, for accomplishing most complicated text-processing tasks. This talk is about how the seemingly simple prospect of parsing text turned into a new parser toolkit for Erlang, and why functional programming makes parsing fun and awesome.

Achieving Parsing Sanity In Erlang

Sean Cribbs

Erlang/OTP for Rubyists

Sean Cribbs

Content Management That Won't Rot Your Brain

Sean Cribbs

Más de Sean Cribbs (19)

Eventually Consistent Data Structures (from strangeloop12)

Eventually-Consistent Data Structures

A Case of Accidental Concurrency

Embrace NoSQL and Eventual Consistency with Ripple

Riak with node.js

Schema Design for Riak (Take 2)

Riak (Øredev nosql day)

Riak Tutorial (Øredev)

The Radiant Ethic

Introduction to Riak and Ripple (KC.rb)

Riak with Rails

Schema Design for Riak

Introduction to Riak - Red Dirt Ruby Conf Training

Introducing Riak and Ripple

Round PEG, Round Hole - Parsing Functionally

Story Driven Development With Cucumber

Achieving Parsing Sanity In Erlang

Erlang/OTP for Rubyists

Content Management That Won't Rot Your Brain

Último

ICT role in 21st century education and its challenges

rafiqahmad00786416

Dubai, often portrayed as a shimmering oasis in the desert, faces its own set of challenges, including the occasional threat of flooding. Despite its reputation for opulence and modernity, the emirate is not immune to the forces of nature. In recent years, Dubai has experienced sporadic but significant floods, testing the resilience of its infrastructure and communities. Among the critical lifelines in this bustling metropolis is the Dubai International Airport, a bustling hub that connects the city to the world. This article explores the intersection of Dubai flood events and the resilience demonstrated by the Dubai International Airport in the face of such challenges.

Navigating the Deluge_ Dubai Floods and the Resilience of Dubai International...

Orbitshub

EMPOWERMENT TECHNOLOGY GRADE 11 QUARTER 2 REVIEWER

MadyBayot

Vector Search -An Introduction in Oracle Database 23ai.pptx

Remote DBA Services

Effective data discovery is crucial for maintaining compliance and mitigating risks in today's rapidly evolving privacy landscape. However, traditional manual approaches often struggle to keep pace with the growing volume and complexity of data. Join us for an insightful webinar where industry leaders from TrustArc and Privya will share their expertise on leveraging AI-powered solutions to revolutionize data discovery. You'll learn how to: - Effortlessly maintain a comprehensive, up-to-date data inventory - Harness code scanning insights to gain complete visibility into data flows leveraging the advantages of code scanning over DB scanning - Simplify compliance by leveraging Privya's integration with TrustArc - Implement proven strategies to mitigate third-party risks Our panel of experts will discuss real-world case studies and share practical strategies for overcoming common data discovery challenges. They'll also explore the latest trends and innovations in AI-driven data management, and how these technologies can help organizations stay ahead of the curve in an ever-changing privacy landscape.

TrustArc Webinar - Unlock the Power of AI-Driven Data Discovery

TrustArc

"I see eyes in my soup": How Delivery Hero implemented the safety system for ...

Zilliz

Six Myths about Ontologies: The Basics of Formal Ontology

johnbeverley2021

How to Troubleshoot Apps for the Modern Connected Worker

ThousandEyes

The Good, the Bad and the Governed - Why is governance a dirty word? David O'Neill, Chief Operating Officer - APIContext Apidays New York 2024: The API Economy in the AI Era (April 30 & May 1, 2024) ------ Check out our conferences at https://www.apidays.global/ Do you want to sponsor or talk at one of our conferences? https://apidays.typeform.com/to/ILJeAaV8 Learn more on APIscene, the global media made by the community for the community: https://www.apiscene.io Explore the API ecosystem with the API Landscape: https://apilandscape.apiscene.io/

Apidays New York 2024 - The Good, the Bad and the Governed by David O'Neill, ...

apidays

Architecting Cloud Native Applications

WSO2

Tracing the root cause of a performance issue requires a lot of patience, experience, and focus. It’s so hard that we sometimes attempt to guess by trying out tentative fixes, but that usually results in frustration, messy code, and a considerable waste of time and money. This talk explains how to correctly zoom in on a performance bottleneck using three levels of profiling: distributed tracing, metrics, and method profiling. After we learn to read the JVM profiler output as a flame graph, we explore a series of bottlenecks typical for backend systems, like connection/thread pool starvation, invisible aspects, blocking code, hot CPU methods, lock contention, and Virtual Thread pinning, and we learn to trace them even if they occur in library code you are not familiar with. Attend this talk and prepare for the performance issues that will eventually hit any successful system. About authorWith two decades of experience, Victor is a Java Champion working as a trainer for top companies in Europe. Five thousands developers in 120 companies attended his workshops, so he gets to debate every week the challenges that various projects struggle with. In return, Victor summarizes key points from these workshops in conference talks and online meetups for the European Software Crafters, the world’s largest developer community around architecture, refactoring, and testing. Discover how Victor can help you on victorrentea.ro : company training catalog, consultancy and YouTube playlists.

Finding Java's Hidden Performance Traps @ DevoxxUK 2024

Victor Rentea

💥 You’re lucky! We’ve found two different (lead) developers that are willing to share their valuable lessons learned about using UiPath Document Understanding! Based on recent implementations in appealing use cases at Partou and SPIE. Don’t expect fancy videos or slide decks, but real and practical experiences that will help you with your own implementations. 📕 Topics that will be addressed: • Training the ML-model by humans: do or don't? • Rule-based versus AI extractors • Tips for finding use cases • How to start 👨‍🏫👨‍💻 Speakers: o Dion Morskieft, RPA Product Owner @Partou o Jack Klein-Schiphorst, Automation Developer @Tacstone Technology

DEV meet-up UiPath Document Understanding May 7 2024 Amsterdam

UiPathCommunity

When you’re building (micro)services, you have lots of framework options. Spring Boot is no doubt a popular choice. But there’s more! Take Quarkus, a framework that’s considered the rising star for Kubernetes-native Java. It always depends on what's best for your situation, but how to choose the best solution if you're comparing 2 frameworks? Both Spring Boot and Quarkus have their positives and negatives. Let us compare the two by live coding a couple of common use cases in Spring Boot and Quarkus. After this talk, you’ll be ready to get started with Quarkus yourself, and know when to select Quarkus or Spring Boot.

Spring Boot vs Quarkus the ultimate battle - DevoxxUK

Jago de Vreede

Passkeys: Developing APIs to enable passwordless authentication Cody Salas, Sr Developer Advocate | Solutions Architect - Yubico Apidays New York 2024: The API Economy in the AI Era (April 30 & May 1, 2024) ------ Check out our conferences at https://www.apidays.global/ Do you want to sponsor or talk at one of our conferences? https://apidays.typeform.com/to/ILJeAaV8 Learn more on APIscene, the global media made by the community for the community: https://www.apiscene.io Explore the API ecosystem with the API Landscape: https://apilandscape.apiscene.io/

Apidays New York 2024 - Passkeys: Developing APIs to enable passwordless auth...

apidays

[BuildWithAI] Introduction to Gemini.pdf

Sandro Moreira

presentation ICT roal in 21st century education

jfdjdjcjdnsjd

Retrieval augmented generation (RAG) is the most popular style of large language model application to emerge from 2023. The most basic style of RAG works by vectorizing your data and injecting it into a vector database like Milvus for retrieval to augment the text output generated by an LLM. This is just the beginning. One of the ways that we can extend RAG, and extend AI, is through multilingual use cases. Typical RAG is done in English using embedding models that are trained in English. In this talk, we’ll explore how RAG could work in languages other than English. We’ll explore French, Chinese, and Polish.

Introduction to Multilingual Retrieval Augmented Generation (RAG)

Zilliz

The presentation was made in “Web3 Fusion: Embracing AI and Beyond” is more than a conference; it's a journey into the heart of digital transformation. The conference a provided a platform where the future of technology meets practical application. This three-day hybrid event, set in the heart of innovation, served as a gateway to the latest trends and transformative discussions in AI, Blockchain, IoT, AR/VR, and their collective impact on the information space.

AI in Action: Real World Use Cases by Anitaraj

AnitaRaj43

Following the popularity of “Cloud Revolution: Exploring the New Wave of Serverless Spatial Data,” we’re thrilled to announce this much-anticipated encore webinar. In this sequel, we’ll dive deeper into the Cloud-Native realm by uncovering practical applications and FME support for these new formats, including COGs, COPC, FlatGeoBuf, GeoParquet, STAC, and ZARR. Building on the foundation laid by industry leaders Michelle Roby of Radiant Earth and Chris Holmes of Planet in the first webinar, this second part offers an in-depth look at the real-world application and behind-the-scenes dynamics of these cutting-edge formats. We will spotlight specific use-cases and workflows, showcasing their efficiency and relevance in practical scenarios. Discover the vast possibilities each format holds, highlighted through detailed discussions and demonstrations. Our expert speakers will dissect the key aspects and provide critical takeaways for effective use, ensuring attendees leave with a thorough understanding of how to apply these formats in their own projects. Elevate your understanding of how FME supports these cutting-edge technologies, enhancing your ability to manage, share, and analyze spatial data. Whether you’re building on knowledge from our initial session or are new to the serverless spatial data landscape, this webinar is your gateway to mastering cloud-native formats in your workflows.

Cloud Frontiers: A Deep Dive into Serverless Spatial Data and FME

Safe Software

Artificial Intelligence Chap.5 : Uncertainty

Khushali Kathiriya

Of Rats And Dragons

1. Of Rats And Dragons Achieving Parsing Sanity Sean Cribbs Web Consultant Ruby and Erlang Hacker Saturday, September 12, 2009

2. Quick Review Saturday, September 12, 2009

3. context-free grammars Saturday, September 12, 2009

4. G = (V, Σ, R, S) Saturday, September 12, 2009

5. V→w Saturday, September 12, 2009

6. non-deterministic pushdown automata Saturday, September 12, 2009

7. stack machine w/ backtracking Saturday, September 12, 2009

8. massage it Saturday, September 12, 2009

9. ε productions Saturday, September 12, 2009

10. produce nothing never produced Saturday, September 12, 2009

11. cycles Saturday, September 12, 2009

12. ambiguities “dangling else” Saturday, September 12, 2009

13. if A then if B then C else D if A then if B then C else D if A then if B then C else D Saturday, September 12, 2009

14. parsing expression grammars Saturday, September 12, 2009

15. top-down parsing language (70’s) Saturday, September 12, 2009

16. direct representation of parsing functions Saturday, September 12, 2009

17. Brian Ford 2002 Saturday, September 12, 2009

18. focused on recognizing Saturday, September 12, 2009

19. computer languages Saturday, September 12, 2009

20. V←e Saturday, September 12, 2009

21. e1 e2 Saturday, September 12, 2009

22. e1 / e2 Saturday, September 12, 2009

23. e+ Saturday, September 12, 2009

24. e* Saturday, September 12, 2009

25. &e Saturday, September 12, 2009

26. !e Saturday, September 12, 2009

27. e? Saturday, September 12, 2009

28. “string” . Saturday, September 12, 2009

29. PEG > regexps Saturday, September 12, 2009

30. combined lex+parse Saturday, September 12, 2009

31. no ambiguity Saturday, September 12, 2009

32. choice is ordered Saturday, September 12, 2009

33. dangling else obviated Saturday, September 12, 2009

34. greedy repetition Saturday, September 12, 2009

35. unlimited lookahead with predicates Saturday, September 12, 2009

36. no left-recursion! (use *,+) Saturday, September 12, 2009

37. Parsing Techniques Saturday, September 12, 2009

38. Tabular test every rule Saturday, September 12, 2009

39. Recursive-descent call & consume Saturday, September 12, 2009

40. Predictive yacc/yecc Saturday, September 12, 2009

41. Packrat RD with memo Saturday, September 12, 2009

42. sacriﬁce memory for speed Saturday, September 12, 2009

43. supports PEGs and some CFGs Saturday, September 12, 2009

44. Treetop Pappy neotoma Saturday, September 12, 2009

45. neotoma Behind the CodeTM Saturday, September 12, 2009

46. can:has(cukes) -> false. Saturday, September 12, 2009

47. Cucumber uses Treetop Saturday, September 12, 2009

48. PEG → leex/yecc FAIL Saturday, September 12, 2009

49. parsec → eParSec Saturday, September 12, 2009

50. HOF protocol Saturday, September 12, 2009

51. % Implements "?" PEG operator optional(P) -> fun(Input, Index) -> case P(Input, Index) of {fail, _} -> {[], Input, Index}; {_,_,_} = Success -> Success % {Parsed, RemainingInput, NewIndex} end end. Saturday, September 12, 2009

52. % PEG optional_space <- space?; % Erlang optional_space(Input,Index) -> optional(fun space/2)(Input, Index). Saturday, September 12, 2009

53. Yay! RD! make it memo Saturday, September 12, 2009

54. ets Erlang Term Storage Saturday, September 12, 2009

55. {key, value} Saturday, September 12, 2009

56. key = Index Saturday, September 12, 2009

57. value = dict Saturday, September 12, 2009

58. % Memoization wrapper p(Inp, StartIndex, Name, ParseFun, TransformFun) -> % Grab the memo table from ets Memo = get_memo(StartIndex), % See if the current reduction is memoized case dict:find(Name, Memo) of % If it is, return the result {ok, Result} -> Result; % If not, attempt to parse _ -> case ParseFun(Inp, StartIndex) of % If it fails, memoize the failure {fail,_} = Failure -> memoize(StartIndex, dict:store(Name, Failure, Memo)), Failure; % If it passes, transform and memoize the result. {Result, InpRem, NewIndex} -> Transformed = TransformFun(Result, StartIndex), memoize(StartIndex, dict:store(Name, {Transformed, InpRem, NewIndex}, Memo)), {Transformed, InpRem, NewIndex} end end. Saturday, September 12, 2009

59. parse_transform Saturday, September 12, 2009

60. alternative(Input, Index) -> peg:p(Input, Index, alternative, fun(I,P) -> peg:choose([fun sequence/2, fun primary/2])(I,P) end). rule(alternative) -> peg:choose([fun sequence/2, fun primary/2]); Saturday, September 12, 2009

61. rules <- space? declaration_sequence space?; declaration_sequence <- head:declaration tail:(space declaration)*; declaration <- nonterminal space '<-' space parsing_expression space? ';'; parsing_expression <- choice / sequence / primary; choice <- head:alternative tail:(space '/' space alternative)+; alternative <- sequence / primary; primary <- prefix atomic / atomic suffix / atomic; sequence <- head:labeled_sequence_primary tail:(space labeled_sequence_primary)+; labeled_sequence_primary <- label? primary; label <- alpha_char alphanumeric_char* ':'; suffix <- repetition_suffix / optional_suffix; optional_suffix <- '?'; repetition_suffix <- '+' / '*'; prefix <- '&' / '!'; atomic <- terminal / nonterminal / parenthesized_expression; parenthesized_expression <- '(' space? parsing_expression space? ')'; nonterminal <- alpha_char alphanumeric_char*; terminal <- quoted_string / character_class / anything_symbol; quoted_string <- single_quoted_string / double_quoted_string; double_quoted_string <- '"' string:(!'"' ("" / '"' / .))* '"'; single_quoted_string <- "'" string:(!"'" ("" / "'" / .))* "'"; character_class <- '[' characters:(!']' ('' . / !'' .))+ '] anything_symbol <- '.'; alpha_char <- [a-z_]; alphanumeric_char <- alpha_char / [0-9]; space <- (white / comment_to_eol)+; comment_to_eol <- '%' (!"n" .)*; white <- [ tnr]; Saturday, September 12, 2009

62. self-hosting Saturday, September 12, 2009

63. Future directions Saturday, September 12, 2009

64. self-contained parsers Saturday, September 12, 2009

65. inline code in PEG Saturday, September 12, 2009

66. Reia retem sedate Saturday, September 12, 2009

67. questions? Saturday, September 12, 2009

Of Rats And Dragons

Recomendados

Recomendados

Más contenido relacionado

Destacado

Destacado (16)

Similar a Of Rats And Dragons

Similar a Of Rats And Dragons (20)

Más de Sean Cribbs

Más de Sean Cribbs (19)

Último

Último (20)

Of Rats And Dragons