Verfügbarkeit: Domain-specific languages

Domain-specific languages:

Gespeichert in:

Bibliographische Detailangaben
1. Verfasser:	Fowler, Martin 1963- (VerfasserIn)
Format:	Buch
Sprache:	English
Veröffentlicht:	Upper Saddle River, NJ [u.a.] Addison-Wesley 2011
Schriftenreihe:	The Addison-Wesley signature series
Schlagworte:	Programming languages (Electronic computers) Domain-specific programming languages Domänenspezifische Programmiersprache
Online-Zugang:	Inhaltsverzeichnis
Beschreibung:	Literaturverz. S. [579] - 580
Beschreibung:	XXVIII, 597 S. graph. Darst.
ISBN:	0321712943 9780321712943

Internformat

MARC


LEADER	00000nam a2200000 c 4500
001	BV036773457
003	DE-604
005	20170719
007	t
008	101112s2011 xxud\|\|\| \|\|\|\| 00\|\|\| eng d
020			\|a 0321712943 \|9 0-321-71294-3
020			\|a 9780321712943 \|9 978-0-321-71294-3
035			\|a (OCoLC)699856769
035			\|a (DE-599)BVBBV036773457
040			\|a DE-604 \|b ger \|e aacr
041	0		\|a eng
044			\|a xxu \|c US
049			\|a DE-92 \|a DE-703 \|a DE-473 \|a DE-634 \|a DE-859 \|a DE-M347 \|a DE-526 \|a DE-Aug4 \|a DE-384 \|a DE-29T \|a DE-11 \|a DE-20 \|a DE-858 \|a DE-898 \|a DE-523 \|a DE-573 \|a DE-1051 \|a DE-739 \|a DE-863
050		0	\|a QA76.7
082	0		\|a 005.13
084			\|a ST 230 \|0 (DE-625)143617: \|2 rvk
084			\|a ST 240 \|0 (DE-625)143625: \|2 rvk
100	1		\|a Fowler, Martin \|d 1963- \|e Verfasser \|0 (DE-588)115868321 \|4 aut
245	1	0	\|a Domain-specific languages \|c Martin Fowler
264		1	\|a Upper Saddle River, NJ [u.a.] \|b Addison-Wesley \|c 2011
300			\|a XXVIII, 597 S. \|b graph. Darst.
336			\|b txt \|2 rdacontent
337			\|b n \|2 rdamedia
338			\|b nc \|2 rdacarrier
490	0		\|a The Addison-Wesley signature series
500			\|a Literaturverz. S. [579] - 580
650		4	\|a Programming languages (Electronic computers)
650		4	\|a Domain-specific programming languages
650	0	7	\|a Domänenspezifische Programmiersprache \|0 (DE-588)7585264-0 \|2 gnd \|9 rswk-swf
689	0	0	\|a Domänenspezifische Programmiersprache \|0 (DE-588)7585264-0 \|D s
689	0		\|5 DE-604
856	4	2	\|m Digitalisierung UB Bayreuth \|q application/pdf \|u http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=020690261&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA \|3 Inhaltsverzeichnis
999			\|a oai:aleph.bib-bvb.de:BVB01-020690261

Datensatz im Suchindex

DE-BY-863_location	1000 1340
DE-BY-FWS_call_number	1000/ST 240 F785 1340/ST 240 F787
DE-BY-FWS_katkey	412647
DE-BY-FWS_media_number	083101354793 083101356513
_version_	1806176086835331072
adam_text	Contents Preface .........................................................................................................xix Part I: Narratives ............................................................................................1 Chapter 1: An Introductory Example .......................................................3 Gothic Security ..................................................................................3 Miss Grant s Controller ................................................................ 4 The State Machine Model ..................................................................5 Programming Miss Grant s Controller ...............................................9 Languages and Semantic Model .......................................................16 Using Code Generation ....................................................................19 Using Language Workbenches .........................................................22 Visualization ....................................................................................24 Chapter 2: Using Domain-Specific Languages ........................................27 Defining Domain-Specific Languages ...............................................27 Boundaries of DSLs ...................................................................... 29 Fragmentary and Stand-alone DSLs ................................................ 32 Why Use a DSL? ..............................................................................33 Improving Development Productivity ............................................. 33 Communication with Domain Experts ............................................ 34 Change in Execution Context ........................................................ 35 Alternative Computaţional Model .................................................. 36 Problems with DSLs ........................................................................36 Language Cacophony ................................................................... 37 Cost of Building ........................................................................... 37 Ghetto Language ......................................................................... 38 Blinkered Abstraction ................................................................... 39 VII Contents Wider Language Processing .............................................................39 DSLLifecycle ...................................................................................40 What Makes a Good DSL Design? ..................................................42 Chapter 3: Implementing DSLs ..............................................................43 Architecture of DSL Processing ........................................................43 The Workings of a Parser ................................................................47 Grammars, Syntax, and Semantics ...................................................49 Parsing Data ....................................................................................50 Macros ............................................................................................52 Testing DSLs ...................................................................................53 Testing the Semantic Model ........................................................... 53 Testing the Parser ......................................................................... 57 Testing the Scripts ........................................................................ 61 Handling Errors ...............................................................................62 Migrating DSLs ...............................................................................64 Chapter 4: Implementing an Internal DSL ..............................................67 Fluent and Command-Query APIs ...................................................68 The Need for a Parsing Layer ..........................................................71 Using Functions ...............................................................................72 Literal Collections ...........................................................................77 Using Grammars to Choose Internal Elements .................................79 Closures ...........................................................................................80 Parse Tree Manipulation .................................................................82 Annotation ......................................................................................84 Literal Extension .............................................................................85 Reducing the Syntactic Noise ...........................................................85 Dynamic Reception .........................................................................86 Providing Some Type Checking .......................................................87 Chapter 5: Implementing an External DSL .............................................89 Syntactic Analysis Strategy ..............................................................89 Output Production Strategy .............................................................92 Parsing Concepts .............................................................................94 Separated hexing ......................................................................... 94 Grammars and Languages ............................................................. 95 Regular, Context-Free, and Context-Sensitive Grammars .................. 96 Top-Down and Bottom-Up Parsing ................................................ 98 Contents Mixing-in Another Language .........................................................100 XML DSLs ....................................................................................101 Chapter 6: Choosing between Internal and External DSLs ...................105 Learning Curve ..............................................................................105 Cost of Building .............................................................................106 Programmer Familiarity .................................................................107 Communication with Domain Experts ...........................................108 Mixing In the Host Language ........................................................108 Strong Expressiveness Boundary ....................................................109 Runtime Configuration ..................................................................110 Sliding into Generality ...................................................................110 Composing DSLs ........................................................................... Ill Summing Up .................................................................................. Ill Chapter 7: Alternative Computational Models .....................................113 A Few Alternative Models .............................................................116 Decision Table ............................................................................. 116 Production Rule System ................................................................ 117 State Machine .............................................................................. 118 Dependency Network ................................................................... 119 Choosing a Model ........................................................................ 120 Chapter 8: Code Generation ................................................................121 Choosing What to Generate ...........................................................122 How to Generate ...........................................................................124 Mixing Generated and Handwritten Code .....................................126 Generating Readable Code ............................................................127 Preparse Code Generation .............................................................128 Further Reading .............................................................................128 Chapter 9: Language Workbenches ......................................................129 Elements of Language Workbenches ..............................................130 Schema Definition Languages and Meta-Models ............................131 Source and Projectional Editing .....................................................136 Multiple Representations ...............................................................138 Illustrative Programming ...............................................................138 Tools Tour .....................................................................................140 Language Workbenches and CASE tools .......................................141 Should You Use a Language Workbench? ......................................142 τ Contents Part II: Common Topics .............................................................................145 Chapter 10: A Zoo of DSLs .................................................................147 Graphviz ........................................................................................147 JMock ............................................................................................149 CSS ................................................................................................150 Hibernate Query Language (HQL) ................................................151 XAML ...........................................................................................152 FIT .................................................................................................155 Make et al...................................................................................... 156 Chapter 11: Semantic Model ................................................................159 How It Works ................................................................................159 When to Use It ...............................................................................162 The Introductory Example (Java) ...................................................163 Chapter 12: Symbol Table .............................;.....................................165 How It Works ................................................................................166 Statically Typed Symbols ............................................................... 167 When to Use It ...............................................................................168 Further Reading .............................................................................168 Dependency Network in an External DSL (Java and ANTLR) .......168 Using Symbolic Keys in an Internal DSL (Ruby) ............................170 Using Enums for Statically Typed Symbols (Java) ..........................172 Chapter 13: Context Variable ..............................................................175 How It Works ................................................................................175 When to Use It ...............................................................................176 Reading an INI File (C#) ................................................................176 Chapter 14: Construction Builder ........................................................179 How It Works ................................................................................179 When to Use It ...............................................................................180 Building Simple Flight Data (C#) ...................................................180 Chapter 15: Macro ...............................................................................183 How It Works ................................................................................184 Textual Macros ............................................................................ 184 Syntactic Macros .......................................................................... 188 When to Use It ...............................................................................192 Contents Chapter 16: Notification ......................................................................193 How It Works ................................................................................194 When to Use It ...............................................................................194 A Very Simple Notification (C#) ....................................................194 Parsing Notification (Java) .............................................................195 Part III: External DSL Topics .....................................................................199 Chapter 17: Delimiter-Directed Translation .........................................201 How It Works ................................................................................201 When to Use It ...............................................................................204 Frequent Customer Points (C#) ......................................................205 Semantic Model ...........................................................................205 The Parser ...................................................................................207 Parsing Nonautonomous Statements with Miss Grant s Controller (Java) .............................................................................................211 Chapter 18: Syntax-Directed Translation .............................................219 How It Works ................................................................................220 The Lexer ...................................................................................221 Syntactic Analyzer ........................................................................223 Output Production .......................................................................226 Semantic Predicates ......................................................................226 When to Use It ...............................................................................227 Further Reading .............................................................................227 Chapter 19: BNF ..................................................................................229 How It Works ................................................................................229 Multiplicity Symbols (Kleene Operators) .........................................231 Some Other Useful Operators ........................................................232 Parsing Expression Grammars .......................................................233 Converting EBNF to Basic BNF .....................................................234 Code Actions ...............................................................................236 When to Use It ...............................................................................238 Chapter 20: Regex Table Lexer (by Rebecca Parsons) .........................239 How It Works ................................................................................240 When to Use It ...............................................................................241 LexingMiss Grant s Controller (Java) ...........................................241 ▼ Contents Chapter 21: Recursive Descent Parser (by Rebecca Parsons) ................245 How It Works ................................................................................246 When to Use It ...............................................................................249 Further Reading .............................................................................249 Recursive Descent and Miss Grant s Controller (Java) ...................250 Chapter 22: Parser Combinator (by Rebecca Parsons) .........................255 How It Works ................................................................................256 Dealing with the Actions ..............................................................259 Functional Style of Combinators ....................................................260 When to Use It ...............................................................................261 Parser Combinators and Miss Grant s Controller (Java) ................261 Chapter 23: Parser Generator ...............................................................269 How It Works ................................................................................269 Embedding Actions ......................................................................270 When to Use It ...............................................................................272 Hello World (Java and ANTLR) ....................................................272 Writing the Basic Grammar ...........................................................272 Building the Syntactic Analyzer ......................................................274 Adding Code Actions to the Grammar ............................................276 Using Generation Gap ..................................................................278 Chapter 24: Tree Construction ............................................................281 How It Works ................................................................................281 When to Use It ...............................................................................284 Using ANTLR s Tree Construction Syntax (Java and ANTLR) .....284 Tokenizing ..................................................................................285 Parsing .......................................................................................286 Populating the Semantic Model ......................................................288 Tree Construction Using Code Actions (Java and ANTLR) ...........292 Chapter 25: Embedded Translation .....................................................299 How It Works ................................................................................299 When to Use It ...............................................................................300 Miss Grant s Controller (Java and ANTLR) ..................................300 Chapter 26: Embedded Interpretation ..................................................305 How It Works ................................................................................305 When to Use It ...............................................................................306 A Calculator (ANTLR and Java) ...................................................306 Contents Chapter 27: Foreign Code ....................................................................309 How It Works ................................................................................309 When to Use It ...............................................................................311 Embedding Dynamic Code (ANTLR, Java, and Javascript) ...........311 Semantic Model ...........................................................................312 Parser .........................................................................................315 Chapter 28: Alternative Tokenization ..................................................319 How It Works ................................................................................319 Quoting ......................................................................................320 Lexical State ................................................................................322 Token Type Mutation ...................................................................324 Ignoring Token Types ...................................................................325 When to Use It ...............................................................................326 Chapter 29: Nested Operator Expression .............................................327 How It Works ................................................................................327 Using Bottom-Up Parsers ..............................................................328 Top-Down Parsers .......................................................................329 When to Use It ...............................................................................331 Chapter 30: Newline Separators ...........................................................333 How It Works ................................................................................333 When to Use It ...............................................................................335 Chapter 31: External DSL Miscellany ..................................................337 Syntactic Indentation .....................................................................337 Modular Grammars .......................................................................339 Part IV: Internal DSL Topics ......................................................................341 Chapter 32: Expression Builder ............................................................343 How It Works ................................................................................344 When to Use It ...............................................................................344 A Fluent Calendar with and without a Builder (Java) ....................345 Using Multiple Builders for the Calendar (Java) .............................348 Chapter 33: Function Sequence ............................................................351 How It Works ................................................................................351 When to Use It ...............................................................................352 Simple Computer Configuration (Java) ..........................................352 У Contents Chapter 34: Nested Function ...............................................................357 How It Works ................................................................................357 When to Use It ...............................................................................359 The Simple Computer Configuration Example (Java) ....................360 Handling Multiple Different Arguments with Tokens (C#) ............361 Using Subtype Tokens for IDE Support (Java) ...............................363 Using Object Initializers (C#) .........................................................365 Recurring Events (C#) ....................................................................366 Semantic Model ...........................................................................366 The DSL .....................................................................................369 Chapter 35: Method Chaining .............................................................373 How It Works ................................................................................373 Builders or Values ........................................................................375 Finishing Problem ........................................................................375 Hierarchic Structure .....................................................................376 Progressive Interfaces ...................................................................377 When to Use It ...............................................................................377 The Simple Computer Configuration Example (Java) ....................378 Chaining with Properties (C#) .......................................................381 Progressive Interfaces (C#) .............................................................382 Chapter 36: Object Scoping .................................................................385 How It Works ................................................................................386 When to Use It ...............................................................................386 Security Codes (C#) .......................................................................387 Semantic Model ...........................................................................387 DSL ...........................................................................................390 Using Instance Evaluation (Ruby) ..................................................392 Using an Instance Initializer (Java) .................................................394 Chapter 37: Closure .............................................................................397 How It Works ................................................................................397 When to Use It ...............................................................................402 Chapter 38: Nested Closure .................................................................403 How It Works ................................................................................403 When to Use It ...............................................................................405 Wrapping a Function Sequence in a Nested Closure (Ruby) ..........405 Simple C# Example (C#) ................................................................408 Using Method Chaining (Ruby) .....................................................409 Contents Function Sequence with Explicit Closure Arguments (Ruby) .........411 Using Instance Evaluation (Ruby) ..................................................412 Chapter 39: Literal List ........................................................................417 How It Works ................................................................................417 When to Use It ...............................................................................417 Chapter 40: Literal Map ......................................................................419 How It Works ................................................................................419 When to Use It ...............................................................................420 The Computer Configuration Using Lists and Maps (Ruby) ..........420 Evolving to Greenspun Form (Ruby) .............................................422 Chapter 41: Dynamic Reception ..........................................................427 How It Works ................................................................................428 When to Use It ...............................................................................429 Promotion Points Using Parsed Method Names (Ruby) .................430 Model .........................................................................................431 Builder ........................................................................................433 Promotion Points Using Chaining (Ruby) ......................................434 Model .........................................................................................435 Builder ........................................................................................435 Removing Quoting in the Secret Panel Controller (JRuby) .............438 Chapter 42: Annotation .......................................................................445 How It Works ................................................................................446 Defining an Annotation ................................................................446 Processing Annotations .................................................................447 When to Use It ...............................................................................449 Custom Syntax with Runtime Processing (Java) .............................449 Using a Class Method (Ruby) ........................................................451 Dynamic Code Generation (Ruby) .................................................452 Chapter 43: Parse Tree Manipulation ..................................................455 How It Works ................................................................................455 When to Use It ...............................................................................456 Generating IMAP Queries from C# Conditions (C#) .....................457 Semantic Model ...........................................................................458 Building from C# .........................................................................460 Stepping Back ..............................................................................465 Contents Chapter 44: Class Symbol Table ..........................................................467 How It Works ................................................................................468 When to Use It ...............................................................................469 Statically Typed Class Symbol Table (Java) ...................................469 Chapter 45: Textual Polishing ..............................................................477 How It Works ................................................................................477 When to Use It ...............................................................................478 Polished Discount Rules (Ruby) .....................................................478 Chapter 46: Literal Extension ..............................................................481 How It Works ................................................................................481 When to Use It ...............................................................................482 Recipe Ingredients (C#) ..................................................................483 Part V: Alternative Computational Models .................................................485 Chapter 47: Adaptive Model ................................................................487 How It Works ................................................................................488 Incorporating Imperative Code into an Adaptive Model ....................489 Tools ..........................................................................................491 When to Use It ...............................................................................492 Chapter 48: Decision Table ..................................................................495 How It Works ................................................................................495 When to Use It ...............................................................................497 Calculating the Fee for an Order (C#) ............................................497 Model .........................................................................................497 The Parser ...................................................................................502 Chapter 49: Dependency Network .......................................................505 How It Works ................................................................................506 When to Use It ...............................................................................508 Analyzing Potions (C#) ..................................................................508 Semantic Model ...........................................................................509 The Parser ...................................................................................511 Chapter 50: Production Rule System ....................................................513 How It Works ................................................................................514 Chaining .....................................................................................515 Contradictory Inferences ...............................................................515 Patterns in Rule Structure ..............................................................516 When to Use It ...............................................................................517 Contents Validations for club membership (C#) ...........................................517 Model .........................................................................................518 Parser .........................................................................................519 Evolving the DSL .........................................................................520 Eligibility Rules: extending the club membership (C#) ...................521 The Model ..................................................................................523 The Parser ...................................................................................525 Chapter 51: State Machine ...................................................................527 How It Works ................................................................................527 When to Use It ...............................................................................529 Secret Panel Controller (Java) ........................................................530 Part VI: Code Generation ...........................................................................531 Chapter 52: Transformer Generation ...................................................533 How It Works ................................................................................533 When to Use It ...............................................................................535 Secret Panel Controller (Java generating C) ...................................535 Chapter 53: Templated Generation ......................................................539 How It Works ................................................................................539 When to Use It ...............................................................................541 Generating the Secret Panel State Machine with Nested Conditionals (Velocity and Java generating C) ....................................................541 Chapter 54: Embedment Helper ...........................................................547 How It Works ................................................................................548 When to Use It ...............................................................................549 Secret Panel States (Java and ANTLR) ...........................................549 Should a Helper Generate HTML? (Java and Velocity) .................552 Chapter 55: Model-Aware Generation .................................................555 How It Works ................................................................................556 When to Use It ...............................................................................556 Secret Panel State Machine (C) ......................................................557 Loading the State Machine Dynamically (C) ..................................564 Chapter 56: Model Ignorant Generation ..............................................567 How It Works ................................................................................567 When to Use It ...............................................................................568 Secret Panel State Machine as Nested Conditionals (C) .................568 Contents Chapter 57: Generation Gap ................................................................571 How It Works ................................................................................571 When to Use It ...............................................................................573 Generating Classes from a Data Schema (Java and a Little Ruby) ...573 Bibliography ...............................................................................................579 Index ..........................................................................................................581
any_adam_object	1
author	Fowler, Martin 1963-
author_GND	(DE-588)115868321
author_facet	Fowler, Martin 1963-
author_role	aut
author_sort	Fowler, Martin 1963-
author_variant	m f mf
building	Verbundindex
bvnumber	BV036773457
callnumber-first	Q - Science
callnumber-label	QA76
callnumber-raw	QA76.7
callnumber-search	QA76.7
callnumber-sort	QA 276.7
callnumber-subject	QA - Mathematics
classification_rvk	ST 230 ST 240
ctrlnum	(OCoLC)699856769 (DE-599)BVBBV036773457
dewey-full	005.13
dewey-hundreds	000 - Computer science, information, general works
dewey-ones	005 - Computer programming, programs, data, security
dewey-raw	005.13
dewey-search	005.13
dewey-sort	15.13
dewey-tens	000 - Computer science, information, general works
discipline	Informatik
format	Book
fullrecord	<?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>01758nam a2200421 c 4500</leader><controlfield tag="001">BV036773457</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">20170719 </controlfield><controlfield tag="007">t</controlfield><controlfield tag="008">101112s2011 xxud\|\|\| \|\|\|\| 00\|\|\| eng d</controlfield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">0321712943</subfield><subfield code="9">0-321-71294-3</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9780321712943</subfield><subfield code="9">978-0-321-71294-3</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)699856769</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)BVBBV036773457</subfield></datafield><datafield tag="040" ind1=" " ind2=" "><subfield code="a">DE-604</subfield><subfield code="b">ger</subfield><subfield code="e">aacr</subfield></datafield><datafield tag="041" ind1="0" ind2=" "><subfield code="a">eng</subfield></datafield><datafield tag="044" ind1=" " ind2=" "><subfield code="a">xxu</subfield><subfield code="c">US</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-92</subfield><subfield code="a">DE-703</subfield><subfield code="a">DE-473</subfield><subfield code="a">DE-634</subfield><subfield code="a">DE-859</subfield><subfield code="a">DE-M347</subfield><subfield code="a">DE-526</subfield><subfield code="a">DE-Aug4</subfield><subfield code="a">DE-384</subfield><subfield code="a">DE-29T</subfield><subfield code="a">DE-11</subfield><subfield code="a">DE-20</subfield><subfield code="a">DE-858</subfield><subfield code="a">DE-898</subfield><subfield code="a">DE-523</subfield><subfield code="a">DE-573</subfield><subfield code="a">DE-1051</subfield><subfield code="a">DE-739</subfield><subfield code="a">DE-863</subfield></datafield><datafield tag="050" ind1=" " ind2="0"><subfield code="a">QA76.7</subfield></datafield><datafield tag="082" ind1="0" ind2=" "><subfield code="a">005.13</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">ST 230</subfield><subfield code="0">(DE-625)143617:</subfield><subfield code="2">rvk</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">ST 240</subfield><subfield code="0">(DE-625)143625:</subfield><subfield code="2">rvk</subfield></datafield><datafield tag="100" ind1="1" ind2=" "><subfield code="a">Fowler, Martin</subfield><subfield code="d">1963-</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)115868321</subfield><subfield code="4">aut</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">Domain-specific languages</subfield><subfield code="c">Martin Fowler</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">Upper Saddle River, NJ [u.a.]</subfield><subfield code="b">Addison-Wesley</subfield><subfield code="c">2011</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">XXVIII, 597 S.</subfield><subfield code="b">graph. Darst.</subfield></datafield><datafield tag="336" ind1=" " ind2=" "><subfield code="b">txt</subfield><subfield code="2">rdacontent</subfield></datafield><datafield tag="337" ind1=" " ind2=" "><subfield code="b">n</subfield><subfield code="2">rdamedia</subfield></datafield><datafield tag="338" ind1=" " ind2=" "><subfield code="b">nc</subfield><subfield code="2">rdacarrier</subfield></datafield><datafield tag="490" ind1="0" ind2=" "><subfield code="a"> The Addison-Wesley signature series</subfield></datafield><datafield tag="500" ind1=" " ind2=" "><subfield code="a">Literaturverz. S. [579] - 580</subfield></datafield><datafield tag="650" ind1=" " ind2="4"><subfield code="a">Programming languages (Electronic computers)</subfield></datafield><datafield tag="650" ind1=" " ind2="4"><subfield code="a">Domain-specific programming languages</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">Domänenspezifische Programmiersprache</subfield><subfield code="0">(DE-588)7585264-0</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="689" ind1="0" ind2="0"><subfield code="a">Domänenspezifische Programmiersprache</subfield><subfield code="0">(DE-588)7585264-0</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="0" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">Digitalisierung UB Bayreuth</subfield><subfield code="q">application/pdf</subfield><subfield code="u">http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=020690261&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA</subfield><subfield code="3">Inhaltsverzeichnis</subfield></datafield><datafield tag="999" ind1=" " ind2=" "><subfield code="a">oai:aleph.bib-bvb.de:BVB01-020690261</subfield></datafield></record></collection>
id	DE-604.BV036773457
illustrated	Illustrated
indexdate	2024-08-01T11:15:44Z
institution	BVB
isbn	0321712943 9780321712943
language	English
oai_aleph_id	oai:aleph.bib-bvb.de:BVB01-020690261
oclc_num	699856769
open_access_boolean
owner	DE-92 DE-703 DE-473 DE-BY-UBG DE-634 DE-859 DE-M347 DE-526 DE-Aug4 DE-384 DE-29T DE-11 DE-20 DE-858 DE-898 DE-BY-UBR DE-523 DE-573 DE-1051 DE-739 DE-863 DE-BY-FWS
owner_facet	DE-92 DE-703 DE-473 DE-BY-UBG DE-634 DE-859 DE-M347 DE-526 DE-Aug4 DE-384 DE-29T DE-11 DE-20 DE-858 DE-898 DE-BY-UBR DE-523 DE-573 DE-1051 DE-739 DE-863 DE-BY-FWS
physical	XXVIII, 597 S. graph. Darst.
publishDate	2011
publishDateSearch	2011
publishDateSort	2011
publisher	Addison-Wesley
record_format	marc
series2	The Addison-Wesley signature series
spellingShingle	Fowler, Martin 1963- Domain-specific languages Programming languages (Electronic computers) Domain-specific programming languages Domänenspezifische Programmiersprache (DE-588)7585264-0 gnd
subject_GND	(DE-588)7585264-0
title	Domain-specific languages
title_auth	Domain-specific languages
title_exact_search	Domain-specific languages
title_full	Domain-specific languages Martin Fowler
title_fullStr	Domain-specific languages Martin Fowler
title_full_unstemmed	Domain-specific languages Martin Fowler
title_short	Domain-specific languages
title_sort	domain specific languages
topic	Programming languages (Electronic computers) Domain-specific programming languages Domänenspezifische Programmiersprache (DE-588)7585264-0 gnd
topic_facet	Programming languages (Electronic computers) Domain-specific programming languages Domänenspezifische Programmiersprache
url	http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=020690261&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA
work_keys_str_mv	AT fowlermartin domainspecificlanguages

Verfügbarkeit

Inhaltsverzeichnis

Würzburg Zentralbibliothek Lesesaal

Bestandesangaben von Würzburg Zentralbibliothek Lesesaal
Signatur:	1000 ST 240 F785
Exemplar 1	ausleihbar Verfügbar Bestellen

Würzburg Teilbibliothek SHL, Raum I.2.11

Bestandesangaben von Würzburg Teilbibliothek SHL, Raum I.2.11
Signatur:	1340 ST 240 F787
Exemplar 1	nicht ausleihbar Checked out – Rückgabe bis: 28.10.2025

MARC

Datensatz im Suchindex

Würzburg Zentralbibliothek Lesesaal

Würzburg Teilbibliothek SHL, Raum I.2.11

Ähnliche Einträge