Practical Scala DSLs Real-World Applications Using Domain Specific Languages — Pierluigi Riti Practical Scala DSLs Real-World Applications Using Domain Specific Languages Pierluigi Riti Practical Scala DSLs: Real-World Applications Using Domain Specific Languages Pierluigi Riti Mullingar, Westmeath, Ireland ISBN-13 (pbk): 978-1-4842-3035-0 ISBN-13 (electronic): 978-1-4842-3036-7 https://doi.org/10.1007/978-1-4842-3036-7 Library of Congress Control Number: 2017962308 Copyright © 2018 by Pierluigi Riti This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed. Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image, we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights. While the advice and information in this book are believed to be true and accurate at the date of publication, neither the author nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made. The publisher makes no warranty, express or implied, with respect to the material contained herein. Cover image by Freepik (www.freepik.com) Managing Director: Welmoed Spahr Editorial Director: Todd Green Acquisitions Editor: Steve Anglin Development Editor: Matthew Moodie Technical Reviewer: Rohan Walia Coordinating Editor: Mark Powers Copy Editor: Michael G. Laraque Distributed to the book trade worldwide by Springer Science+Business Media New York, 233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail [email protected], or visit www.springeronline.com. Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science+Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation. For information on translations, please e-mail [email protected], or visit http://www.apress. com/rights-permissions. Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook versions and licenses are also available for most titles. For more information, reference our Print and eBook Bulk Sales web page at www.apress.com/bulk-sales. Any source code or other supplementary material referenced by the author in this book is available to readers on GitHub via the book’s product page, located at www.apress.com/ 9781484230350. For more detailed information, please visit www.apress.com/source-code. Printed on acid-free paper To my wife, Mara Ester, who brought me the best gift any man could receive: my two children, Nicole and Mattia. I love you. Table of Contents About the Author ���������������������������������������������������������������������������������xi About the Technical Reviewer �����������������������������������������������������������xiii Introduction ����������������������������������������������������������������������������������������xv Chapter 1: Introduction to Scala �����������������������������������������������������������1 Basic Syntax ���������������������������������������������������������������������������������������������������������2 Variable and Value in Scala �����������������������������������������������������������������������������������3 Naming in Scala ����������������������������������������������������������������������������������������������������5 First Example in Scala �������������������������������������������������������������������������������������5 Define a Method and Function in Scala �����������������������������������������������������������6 Classes in Scala ����������������������������������������������������������������������������������������������������8 Singleton Object ����������������������������������������������������������������������������������������������������9 Types in Scala �����������������������������������������������������������������������������������������������������10 Converting Numeric Types �����������������������������������������������������������������������������10 String in Scala �����������������������������������������������������������������������������������������������11 Expressions in Scala �������������������������������������������������������������������������������������������14 Conditional Expression ����������������������������������������������������������������������������������16 Pattern Matching Expression �������������������������������������������������������������������������16 Range and Loop ���������������������������������������������������������������������������������������������20 Other Loops ���������������������������������������������������������������������������������������������������22 Data Structures ���������������������������������������������������������������������������������������������������24 Array ��������������������������������������������������������������������������������������������������������������24 List �����������������������������������������������������������������������������������������������������������������25 v TTaabbllee ooff CCoonnTTeennTTss Set �����������������������������������������������������������������������������������������������������������������26 Tuple ��������������������������������������������������������������������������������������������������������������26 Map����������������������������������������������������������������������������������������������������������������27 Summary�������������������������������������������������������������������������������������������������������������28 Chapter 2: Introduction to DSL �����������������������������������������������������������29 Definition of DSL �������������������������������������������������������������������������������������������������29 Difference Between Internal and External DSLs ��������������������������������������������30 Designing a Good DSL �����������������������������������������������������������������������������������31 Analyze the Domain ���������������������������������������������������������������������������������������32 Creating a Common Dictionary ����������������������������������������������������������������������34 Sample DSLs �������������������������������������������������������������������������������������������������������35 DSL Goals ������������������������������������������������������������������������������������������������������������36 Implementing a DSL ��������������������������������������������������������������������������������������������38 Grammar and Data Parsing ���������������������������������������������������������������������������40 First DSL Implementation ������������������������������������������������������������������������������41 Common DSL Patterns�����������������������������������������������������������������������������������42 Conclusion ����������������������������������������������������������������������������������������������������������43 Chapter 3: Internal DSL �����������������������������������������������������������������������45 Creating an Internal DSL �������������������������������������������������������������������������������������45 Method Chaining ������������������������������������������������������������������������������������������46 Creating a Fluent Interface ���������������������������������������������������������������������������48 Designing the Parsing Layer �������������������������������������������������������������������������������51 Design the Parsing Layer Using Functions ����������������������������������������������������������54 Conclusion ����������������������������������������������������������������������������������������������������������57 Chapter 4: External DSL ����������������������������������������������������������������������59 Internal DSLs vs� External DSLs ��������������������������������������������������������������������������59 Grammar and Syntax ������������������������������������������������������������������������������������������60 vi TTaabbllee ooff CCoonnTTeennTTss Creating an External DSL ������������������������������������������������������������������������������������62 Producing the Output �������������������������������������������������������������������������������������65 What Is a Parser? ������������������������������������������������������������������������������������������66 What Style of DSL to Use �������������������������������������������������������������������������������68 Conclusion ����������������������������������������������������������������������������������������������������������69 Chapter 5: Web API and μService �������������������������������������������������������71 What Is a μService ����������������������������������������������������������������������������������������������71 Communication ���������������������������������������������������������������������������������������������75 The Team �������������������������������������������������������������������������������������������������������77 Innovation ������������������������������������������������������������������������������������������������������77 When to Use Microservices���������������������������������������������������������������������������������78 REST Architecture �����������������������������������������������������������������������������������������������79 Designing Microservices in Scala �����������������������������������������������������������������������83 Installing the Play Framework �����������������������������������������������������������������������83 Designing the REST Microservice������������������������������������������������������������������86 Creating a Microservice in Play ���������������������������������������������������������������������87 Our Own DSL Microservice ����������������������������������������������������������������������������89 Conclusion ����������������������������������������������������������������������������������������������������������95 Chapter 6: User Recognition System ��������������������������������������������������97 Grammar �������������������������������������������������������������������������������������������������������������98 Scala Parser Combinator Library �������������������������������������������������������������������99 A Simple Sample Parser ������������������������������������������������������������������������������101 Defining a Domain Problem and the Grammar �������������������������������������������������103 Preparing the Parser������������������������������������������������������������������������������������105 Describing the Parser ����������������������������������������������������������������������������������107 Improving the JSON Parser �������������������������������������������������������������������������108 Conclusion ��������������������������������������������������������������������������������������������������������112 vii TTaabbllee ooff CCoonnTTeennTTss Chapter 7: Creating a Custom Language ������������������������������������������113 What Is a “Language”? �������������������������������������������������������������������������������������114 Patterns for Designing a Language �������������������������������������������������������������������115 Designing the Language �����������������������������������������������������������������������������������121 Creating the Language ��������������������������������������������������������������������������������������123 Creating the Reader Class ���������������������������������������������������������������������������123 Defining the Token ���������������������������������������������������������������������������������������130 Creating the Translator for the Language ���������������������������������������������������������132 Executing the Language ������������������������������������������������������������������������������������136 Conclusion ��������������������������������������������������������������������������������������������������������137 Chapter 8: Mobile Development��������������������������������������������������������139 Introduction to Mobile Development in Android ������������������������������������������������139 Starting with Android Development�������������������������������������������������������������140 Anatomy of an Android Application �������������������������������������������������������������144 Our First Scala-Android Application ������������������������������������������������������������������147 Creating Services in Android �����������������������������������������������������������������������153 Defining Our DSLs ���������������������������������������������������������������������������������������155 Conclusion ��������������������������������������������������������������������������������������������������������158 Chapter 9: Forex Trading System ������������������������������������������������������159 What Is a Forex Trading System? ����������������������������������������������������������������������159 Designing the DSL System ��������������������������������������������������������������������������161 Implementing the System ���������������������������������������������������������������������������163 Improving the Basic Class ���������������������������������������������������������������������������165 Creating the Order ���������������������������������������������������������������������������������������166 Why It Is Important to Design a Good API ����������������������������������������������������167 Designing the New DSL API ������������������������������������������������������������������������������169 Consuming the First API ������������������������������������������������������������������������������172 viii TTaabbllee ooff CCoonnTTeennTTss Improving the API ����������������������������������������������������������������������������������������172 Adding the Last Functionality ����������������������������������������������������������������������174 Conclusion ��������������������������������������������������������������������������������������������������������179 Chapter 10: Game Development �������������������������������������������������������181 Game Team Structure ���������������������������������������������������������������������������������������181 Engineering Team ����������������������������������������������������������������������������������������182 Artist Team ���������������������������������������������������������������������������������������������������183 Other Actors Involved ����������������������������������������������������������������������������������184 Definition of a Game Engine ������������������������������������������������������������������������������184 Designing Our New DSL Game Engine ��������������������������������������������������������186 Defining the Generic Component �����������������������������������������������������������������188 Other Components ���������������������������������������������������������������������������������������200 Conclusion ��������������������������������������������������������������������������������������������������������207 Chapter 11: Cloud and DevOps ���������������������������������������������������������209 What Is DevOps? �����������������������������������������������������������������������������������������������209 Common DevOps Practice ���������������������������������������������������������������������������������211 Start with AWS ��������������������������������������������������������������������������������������������������212 Deployment and Build in AWS ���������������������������������������������������������������������������214 Creating the Project in AWS �������������������������������������������������������������������������215 Creating the Basic Files �������������������������������������������������������������������������������216 Creating the Build File ���������������������������������������������������������������������������������218 Final Conclusion ������������������������������������������������������������������������������������������������220 Index �������������������������������������������������������������������������������������������������221 ix About the Author Pierluigi Riti has more than 20 years of extensive experience in the design and development of different scale applications, particularly in the telecommunications and financial industries. At present, he is a senior DevOps engineer for a gaming company. He has expansive development skills that encompass the latest technologies, including Java, J2EE, C#, F#, .NET, Spring .NET, EF, WPF, WF, WinForm, WebAPI, MVC, Nunit, Scala, Spring, JSP, EJB, Struts, Struts2, SOAP, REST, C, C++, Hibernate, NHibernate, Weblogic, XML, XSLT, Unix script, Ruby, and Python. Pierluigi loves to read about technology and architecture. When he isn’t working, he enjoys spending time with his family. xi
Description: