DOCSLIB.ORG

Java Magazine, May/June 2017

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Java Magazine, May/June 2017 MAY/JUNE 2017 magazine By and for the Java community Libraries 10 16 34 28 LOMBOK: JDEFERRED’S DATABASE BEST PRACTICES ANNOTATIONS FOR ASYNC EVENT ACCESS WITH FOR LIBRARY CLEANER CODE MANAGEMENT STREAMS DESIGN ORACLE.COM/JAVAMAGAZINE //table of contents / 16 22 28 JDEFERRED: SIMPLE JSOUP HTML DESIGNING AND HANDLING OF PROMISES PARSING LIBRARY IMPLEMENTING AND FUTURES By Mert Çalışkan A LIBRARY By Andrés Almiray Easily parse HTML, extract By Stephen Colebourne Asynchronous operations specified elements, validate The chief designer of Joda- without the headaches structure, and sanitize content. Time lays out best practices for writing your own library. 10 PROJECT LOMBOK: CLEAN, CONCISE CODE By Josh Juneau Add Lombok to your project and get rid of most of your boilerplate code. COVER ART BY PEDRO MURTEIRA 03 34 42 47 From the Editor Databases Fix This User Groups Writing your own annotations? Be Database Actions Using Java 8 By Simon Roberts The Bangladesh JUG circumspect in your design. Stream Syntax Instead of SQL Our latest code quiz 48 05 By Per Minborg 32 Contact Us Events Speedment 3.0 enables Java developers Java Proposals of Interest Have a comment? Suggestion? Want to to stay in Java when writing database Upcoming Java conferences and events JEP 262: Built-in Support for TIFF Files submit an article proposal? Here’s how. applications. 01 ORACLE.COM/JAVAMAGAZINE /////////////////////////////////////////////// MAY/JUNE 2017 EDITORIAL PUBLISHING Editor in Chief Publisher Andrew Binstock Jennifer Hamilton +1.650.506.3794 Managing Editor Associate Publisher and Audience Claire Breen Development Director Copy Editors Karin Kinnear +1.650.506.1985 Karen Perkins, Jim Donahue Audience Development Manager Technical Reviewer Jennifer Kurtz Stephen Chin ADVERTISING SALES DESIGN Sales Director Senior Creative Director Tom Cometa Francisco G Delgadillo Account Manager Design Director Mark Makinney Richard Merchán Mailing-List Rentals Senior Designer Contact your sales representative. Arianna Pucherelli Certified Professional Designer RESOURCES Jaime Ferrand Oracle Products Senior Publication Designer +1.800.367.8674 (US/Canada) Sheila Brennan Oracle Services Production Designer +1.888.283.0591 (US) Kathy Cygnarowicz ARTICLE SUBMISSION If you are interested in submitting an article, please email the editors. SUBSCRIPTION INFORMATION Subscriptions are complimentary for qualified individuals who complete the subscription form. You’ve Earned It MAGAZINE CUSTOMER SERVICE [email protected] Display Your Oracle Certification Digital Badge PRIVACY Oracle Publishing allows sharing of its mailing list with selected third parties. If you prefer that your mailing address or email address not be included in this program, contact Customer Service. Certified Associate Certified Professional Certified Expert Certified Expert Certified Specialist Copyright © 2017, Oracle and/or its affiliates. All Rights Reserved. No part of this publication may be reprinted or otherwise reproduced without permission from the editors. JAVA MAGAZINE IS PROVIDED ON AN “AS IS” BASIS. ORACLE EXPRESSLY DISCLAIMS ALL WARRANTIES, WHETHER EXPRESS OR IMPLIED. IN NO EVENT SHALL ORACLE BE LIABLE FOR ANY DAMAGES OF ANY KIND ARISING FROM YOUR USE OF OR RELIANCE ON ANY INFORMATION PROVIDED HEREIN. Opinions ASSOCIATE PROFESSIONAL EXPERT MASTER SPECIALIST expressed by authors, editors, and interviewees—even if they are Oracle employees—do not necessarily reflect the views of Oracle. The information is intended to outline our general product direction. It is intended for information purposes only, and may not be incorporated into any contract. It is not a commitment to deliver any material, code, or functionality, and should not be relied upon in making purchasing decisions. The development, release, and timing of any features or functionality described for Oracle’s products remains at the sole discretion of Oracle. Oracle and Java are registered trademarks of Oracle Corporation and/or its Claim your certification badge and validate affiliates. Other names may be trademarks of their respective owners. your skills across all online platforms. Java Magazine is published bimonthly and made available at no cost to qualified subscribers by Oracle, 500 Oracle Parkway, MS OPL-3A, Redwood City, CA 94065-1600. 02 ORACLE.COM/JAVAMAGAZINE /////////////////////////////////////////////// MAY/JUNE 2017 //from the editor / Java in the Cloud Keeping Annotations Useful Oracle Cloud delivers When designing annotations, be conservative and circumspect. high-performance and battle-tested platform and infrastructure services for the most demanding n this issue, the lead feature is about a rightly Annotations as they appear in Java itself Java apps. Iwell-regarded library named Project Lombok. follow a similar understated model. Those anno- This library enables you to avoid writing boiler- tations, first unveiled in Java 5, were elegant plate code by using annotations. For example, and concise and didn’t attempt to do too much: Oracle Cloud. add @Data to a class and Lombok will generate the @Override and @Deprecated told you something Built for modern app dev. getters and setters, plus other methods you’re about the code, while @SuppressWarnings told the Built for you. likely to want in a JavaBean-style data class— tools that you knew what you were doing. The toString() and so on. Lombok’s approach is intent was that tools, especially IDEs, would use attractive to me—and to many developers— these markers to issue warnings and reminders. in part because it’s useful, compact, and clear. None of the annotations actually changed pro- In addition, the project includes a tool called gram behavior. This conservative approach by “delombok,” which can remove the annotations the Java language team continued in Java 7, when and insert the boilerplate code into your classes. @SafeVarargs was added, and in Java 8, when In this way, you can easily remove the dependency @FunctionalInterface was delivered. Start here: on Lombok. The annotations are conservative in In addition to the qualities I’ve already men- developer.oracle.com their expression and their roles, and the project tioned, these annotations are unambiguous. This has a clean, reversible implementation. Many more is a key and often overlooked aspect of annota- annotations should follow this approach. tion design. In the quest for brevity, annotation #developersrule PHOTOGRAPH BY BOB ADLER/THE VERBATIM AGENCY 03 ORACLE.COM/JAVAMAGAZINE /////////////////////////////////////////////// MAY/JUNE 2017 //from the editor / authors too often push the respon- As the annotations became com- IntelliJ uses syntax like this: sibility of intelligibility onto plex markers for actions defined @Contract("_, null -> null"). developers. Look no further than elsewhere, you ended up chasing It means that the tagged method the lack of coordination in basic your tail just to determine what the accepts two parameters and syntax. A prime offender here is code you had right before you actu- returns a null if the second param- the family of not-null qualifiers. ally did. This was less than entirely eter is null. Much as I like this @NotNull is such an annotation, fun, which brings me to the second annotation, I feel uncomfortable and so is @NonNull. This annota- problem with many annotations: fully committing to it because it Get a Free tion has a different meaning under insufficient documentation. Unless creates a dependence on the IDE. FindBugs. Likewise, @Nullable the meaning is utterly transparent (Even though another IDE will skip Trial to means different things to the (and even then, as the preceding the annotation it doesn’t recognize, Checker Framework and FindBugs. examples demonstrated), docu- I’ve now left an unused artifact in Oracle Cloud This is not the way to go about ment the annotation thoroughly, my code that might create wasted things. If you author annotations, especially in frameworks. Err on time for downstream developers Experience modern, be clear and definitely avoid syn- the side of overcommunication. trying to understand its function.) open cloud development onyms and homonyms. Finally, I need to stress the In addition, if my whole team is with a free trial to Oracle In comparison to these short, importance of making annota- not using the same IDE, then some Cloud platform and pithy annotations, Java EE intro- tions a sound proposition for the code won’t have these tests and my infrastructure services. duced the extensive use of annota- developer and, by extension, the hope of consistent DbC enforce- tions. Soon, a series of annotations developer’s team. In this regard, ment is either compromised or Get your free trial: replaced code, and the nature of I am leery of IDE vendors’ cre- IDE-dependent. developer.oracle.com enterprise programming thereby ation of their own proprietary Annotations are an important changed. Java EE acquired a sort of annotation systems. All IDEs do part of programming in Java, and embedded syntax that straddled this to some extent, but I’ll pick their role is likely to expand. But descriptions and commands. The an example from the one I use new annotations should be devised advent of this style reinvigorated most. IntelliJ IDEA uses annota- with far greater circumspection Java EE by making it far easier tions to deliver a minimal but than in the past, named with care- to code and by getting rid of the clever implementation of design ful attention to predecessors, and heaviness of its forebears. by contract (DbC)–style enforce- documented
Load more

Recommended publications
  • Weld 3.0.2.Final - CDI Reference Implementation
    Weld 3.0.2.Final - CDI Reference Implementation CDI: Contexts and Dependency In- jection for the Java EE platform by Gavin King, Pete Muir, Jozef Hartinger, Martin Kouba, Dan Allen, and David Allen and thanks to Nicola Benaglia, Gladys Guerrero, Eun- Ju Ki,, Terry Chuang, Francesco Milesi, and Sean Wu A note about naming and nomenclature ............................................................................. ix I. Beans ............................................................................................................................ 1 1. Introduction ......................................................................................................... 5 1.1. What is a bean? ......................................................................................... 5 1.2. Getting our feet wet .................................................................................... 5 2. More about beans ................................................................................................ 9 2.1. The anatomy of a bean ............................................................................. 10 2.1.1. Bean types, qualifiers and dependency injection ............................... 10 2.1.2. Scope ............................................................................................ 13 2.1.3. EL name ........................................................................................ 13 2.1.4. Alternatives .................................................................................... 14 2.1.5. Interceptor
    [Show full text]
  • Composable Concurrency Models
    Composable Concurrency Models Dan Stelljes Division of Science and Mathematics University of Minnesota, Morris Morris, Minnesota, USA 56267 [email protected] ABSTRACT Given that an application is likely to make use of more The need to manage concurrent operations in applications than one concurrency model, programmers would prefer that has led to the development of a variety of concurrency mod- different types of models could safely interact. However, dif- els. Modern programming languages generally provide sev- ferent models do not necessarily work well together, nor are eral concurrency models to serve different requirements, and they designed to. Recent work has attempted to identify programmers benefit from being able to use them in tandem. common \building blocks" that could be used to compose We discuss challenges surrounding concurrent programming a variety of models, possibly eliminating subtle problems and examine situations in which conflicts between models when different models interact and allowing models to be can occur. Additionally, we describe attempts to identify represented at lower levels without resorting to rough ap- features of common concurrency models and develop lower- proximations [9, 11, 12]. level abstractions capable of supporting a variety of models. 2. BACKGROUND 1. INTRODUCTION In a concurrent program, the history of operations may Most interactive computer programs depend on concur- not be the same for every execution. An entirely sequen- rency, the ability to perform different tasks at the same tial program could be proved to be correct by showing that time. A web browser, for instance, might at any point be its history (that is, the sequence in which its operations are rendering documents in multiple tabs, transferring files, and performed) always yields a correct result.
    [Show full text]
  • (Minus Sign) in Class Diagrams, 15 * (Asterisk) As Wildcard, 58 ? (Question
    Index - (minus sign) in class diagrams, 15 AOP module (Spring), 34, 37 * (asterisk) as wildcard, 58 Apache Axis web services framework, 210 ? (question mark) for positional bind Apache Maven, 280–285 variables, 187 Apache Struts framework, 23 + (plus sign) in class diagrams, 15 Apache Tiles framework, 122, 278 Apache Tomcat, 257 ■ A APF (Authentication Processing Filter), AbstractCachingViewResolver class, 60 233–243 AbstractCommandController class, 74–78 application contexts (Spring), 33 AbstractController class, 71–74 Application Controller pattern AbstractEnterpriseBean class, 158, 200 action/command handling, 52–56 AbstractHandlerMapping, 54 action handlers, using, 56–58 AbstractMessageDrivenBean class, 200 for action-view management, 50–52 AbstractProcessingFilter, 234 background, 50–51 AbstractStatelessSessionBean, 158 benefits and concerns, 68 AbstractTemplateViewResolver class, strategies with Spring framework, 52 60–61 view handlers, 59–62, 62–68 AbstractWizardFormController class, 89 application server transactions, 261 access decision manager (Spring application servers, 138 Security), 228 application service implementation class, accessDecisionManager property, 164 246–247 Application Service pattern Acegi Security, 223–224 benefits and concerns, 167 action/command handling (application to concentrate business logic in POJO controller), 52–56 classes, 162–163 action handlers strategies with Spring framework, page controllers and, 51 164–167 sequence, 54 applicationContext-security.xml, 229 using (application controller), 56–58
    [Show full text]
  • Reactive Async: Expressive Deterministic Concurrency
    Reactive Async: Expressive Deterministic Concurrency Philipp Haller Simon Geries Michael Eichberg Guido Salvaneschi KTH Royal Institute of Technology, Sweden TU Darmstadt, Germany [email protected] feichberg, [email protected] Abstract tion can generate non-deterministic results because of their Concurrent programming is infamous for its difficulty. An unpredictable scheduling. Traditionally, developers address important source of difficulty is non-determinism, stemming these problems by protecting state from concurrent access from unpredictable interleavings of concurrent activities. via synchronisation. Yet, concurrent programming remains Futures and promises are widely-used abstractions that help an art: insufficient synchronisation leads to unsound pro- designing deterministic concurrent programs, although this grams but synchronising too much does not exploit hardware property cannot be guaranteed statically in mainstream pro- capabilities effectively for parallel execution. gramming languages. Deterministic-by-construction con- Over the years researchers have proposed concurrency current programming models avoid this issue, but they typi- models that attempt to overcome these issues. For exam- cally restrict expressiveness in important ways. ple the actor model [13] encapsulates state into actors This paper introduces a concurrent programming model, which communicate via asynchronous messages–a solution Reactive Async, which decouples concurrent computations that avoids shared state and hence (low-level) race condi- using
    [Show full text]
  • A Reduction Semantics for Direct-Style Asynchronous Observables
    Journal of Logical and Algebraic Methods in Programming 105 (2019) 75–111 Contents lists available at ScienceDirect Journal of Logical and Algebraic Methods in Programming www.elsevier.com/locate/jlamp A reduction semantics for direct-style asynchronous observables ∗ Philipp Haller a, , Heather Miller b a KTH Royal Institute of Technology, Sweden b Carnegie Mellon University, USA a r t i c l e i n f o a b s t r a c t Article history: Asynchronous programming has gained in importance, not only due to hardware develop- Received 31 January 2016 ments like multi-core processors, but also due to pervasive asynchronicity in client-side Received in revised form 6 March 2019 Web programming and large-scale Web applications. However, asynchronous program- Accepted 6 March 2019 ming is challenging. For example, control-flow management and error handling are much Available online 18 March 2019 more complex in an asynchronous than a synchronous context. Programming with asyn- chronous event streams is especially difficult: expressing asynchronous stream producers and consumers requires explicit state machines in continuation-passing style when using widely-used languages like Java. In order to address this challenge, recent language designs like Google’s Dart introduce asynchronous generators which allow expressing complex asynchronous programs in a familiar blocking style while using efficient non-blocking concurrency control under the hood. However, several issues remain unresolved, including the integration of analogous constructs into statically-typed languages, and the formalization and proof of important correctness properties. This paper presents a design for asynchronous stream generators for Scala, thereby ex- tending previous facilities for asynchronous programming in Scala from tasks/futures to asynchronous streams.
    [Show full text]
  • Perception and Effects of Implementing Kotlin in Existing Projects
    Bachelor thesis Undergraduate level Perception and effects of implementing Kotlin in existing projects A case study about language adoption Author: Emil Sundin Supervisor: Wei Song Examiner: Azadeh Sarkheyli Discipline: Informatics Course: IK2017 Credit: 15 credits Examination date: 2018-05-25 Dalarna University provides the opportunity for publishing the thesis through DiVA as Open Access. This means that the thesis work will become freely available to read and download through their portal. Dalarna University encourages students as well as researchers to publish their work in the Open Access format. We approve the publishing of this thesis work under the Open Access format: Yes ☒ No ☐ Dalarna University – SE-791 88 Falun – Phone +4623-77 80 00 Abstract The Kotlin programming language has seen an increase of adoption since its launch in 2011. In late 2017 Google announced first-class support for Kotlin on the Android platform which further popularized the language. With this increase in popularity we felt it was interesting to investigate how Kotlin affects the developer experience. We performed a case study to see how Java developers perceive the Kotlin language, and how it meets the requirements of these developers. To gather the developer requirements and their perception of Kotlin we performed two sets of interviews and rewrote parts of their codebase. The first set of interviews identified developer requirements and the second set of interviews showcased the Kotlin language and its potential use in their codebase. The results show that Kotlin can meet most of the developer requirements and that the perception of Kotlin is positive. Kotlin’s ability to be incrementally adopted was a prominent feature which reduced the inherent risks of technology adoption while providing them the ability to further evaluate the language.
    [Show full text]
  • Lecture 26: Creational Patterns
    Creational Patterns CSCI 4448/5448: Object-Oriented Analysis & Design Lecture 26 — 11/29/2012 © Kenneth M. Anderson, 2012 1 Goals of the Lecture • Cover material from Chapters 20-22 of the Textbook • Lessons from Design Patterns: Factories • Singleton Pattern • Object Pool Pattern • Also discuss • Builder Pattern • Lazy Instantiation © Kenneth M. Anderson, 2012 2 Pattern Classification • The Gang of Four classified patterns in three ways • The behavioral patterns are used to manage variation in behaviors (think Strategy pattern) • The structural patterns are useful to integrate existing code into new object-oriented designs (think Bridge) • The creational patterns are used to create objects • Abstract Factory, Builder, Factory Method, Prototype & Singleton © Kenneth M. Anderson, 2012 3 Factories & Their Role in OO Design • It is important to manage the creation of objects • Code that mixes object creation with the use of objects can become quickly non-cohesive • A system may have to deal with a variety of different contexts • with each context requiring a different set of objects • In design patterns, the context determines which concrete implementations need to be present © Kenneth M. Anderson, 2012 4 Factories & Their Role in OO Design • The code to determine the current context, and thus which objects to instantiate, can become complex • with many different conditional statements • If you mix this type of code with the use of the instantiated objects, your code becomes cluttered • often the use scenarios can happen in a few lines of code • if combined with creational code, the operational code gets buried behind the creational code © Kenneth M. Anderson, 2012 5 Factories provide Cohesion • The use of factories can address these issues • The conditional code can be hidden within them • pass in the parameters associated with the current context • and get back the objects you need for the situation • Then use those objects to get your work done • Factories concern themselves just with creation, letting your code focus on other things © Kenneth M.
    [Show full text]
  • Prof. Catalin Boja, Phd [email protected] Source Code Quality
    Design patterns Prof. Catalin Boja, PhD [email protected] http://acs.ase.ro/software-quality-testing Source code quality Principles for writing the code: • Easy to read / understand - clear • Easy to modify - structured • Easy to reuse • Simple (complexity) • Easy to test • Implement patterns for the standard problem Left: Simply Explained: Code Reuse 2009-12- acs.ase.ro [email protected] 03.By Oliver Widder, Webcomics Geek Aad Poke.2 Source code quality Forces that influence it: • Available time (delivery terms) • Costs • The experience of the programmer • Programmer competences • Specifications clarity • Solution complexity • Change rates for specifications, requirements, team, etc http://khristianmcfadyen.com/ acs.ase.ro [email protected] 3 Anti-Pattern: Big ball of mud “A Big Ball of Mud is a haphazardly structured, sprawling, sloppy, duct-tape- and-baling-wire, spaghetti- code jungle.” Brian Foote and Joseph Yoder, Big Ball of Mud, September 1997 acs.ase.ro [email protected] 4 Anti-Pattern: Big ball of mud Where from ? Why ? • Throwaway code - Temporary (Prototyping) solutions to be replaced / rewritten • Cut and Paste code • Adapting code by commenting / deleting other solutions • Very short or unrealistic deadlines • Lack of experience • Lack of standards / procedures acs.ase.ro [email protected] 5 Anti-Pattern: Big ball of mud How do you avoid it? • Rewriting the code (Refactoring) to an acceptable maturity level • Use Clean Code Principles • Design Patterns Implementation acs.ase.ro [email protected] 6 Design-pattern • A pattern is a reusable solution for a standard problem in a given context • Facilitates the reuse of architectures and software design • They are not data structures acs.ase.ro [email protected] 7 Design-pattern “A pattern involves a general “..
    [Show full text]
  • Design Patterns in Ocaml
    Design Patterns in OCaml Antonio Vicente [email protected] Earl Wagner [email protected] Abstract The GOF Design Patterns book is an important piece of any professional programmer's library. These patterns are generally considered to be an indication of good design and development practices. By giving an implementation of these patterns in OCaml we expected to better understand the importance of OCaml's advanced language features and provide other developers with an implementation of these familiar concepts in order to reduce the effort required to learn this language. As in the case of Smalltalk and Scheme+GLOS, OCaml's higher order features allows for simple elegant implementation of some of the patterns while others were much harder due to the OCaml's restrictive type system. 1 Contents 1 Background and Motivation 3 2 Results and Evaluation 3 3 Lessons Learned and Conclusions 4 4 Creational Patterns 5 4.1 Abstract Factory . 5 4.2 Builder . 6 4.3 Factory Method . 6 4.4 Prototype . 7 4.5 Singleton . 8 5 Structural Patterns 8 5.1 Adapter . 8 5.2 Bridge . 8 5.3 Composite . 8 5.4 Decorator . 9 5.5 Facade . 10 5.6 Flyweight . 10 5.7 Proxy . 10 6 Behavior Patterns 11 6.1 Chain of Responsibility . 11 6.2 Command . 12 6.3 Interpreter . 13 6.4 Iterator . 13 6.5 Mediator . 13 6.6 Memento . 13 6.7 Observer . 13 6.8 State . 14 6.9 Strategy . 15 6.10 Template Method . 15 6.11 Visitor . 15 7 References 18 2 1 Background and Motivation Throughout this course we have seen many examples of methodologies and tools that can be used to reduce the burden of working in a software project.
    [Show full text]
  • Develop a Simple Web Application with Apache Wicket and Apache
    Develop a simple Web application with Apache Wicket and Apache Geronimo Combine Wicket, Geronimo, and Apache Derby to form an open source Java Web development platform Skill Level: Intermediate Robi Sen ([email protected]) Vice President Department 13 LLC 10 Jul 2007 Apache Wicket is an innovative Java™ Web application framework that was introduced a couple of years ago. It helps simplify Web application development by clearly separating the roles of developers and designers. It lets you remove logical code from the view layer, eliminating the need for JavaServer Pages (JSP), providing a simple plain old Java object (POJO)-centric mode of development, and removing much of the need for XML and other configuration file formats. In this tutorial, learn how to set up your system to develop a simple Web application with Wicket, using Apache Geronimo as your application server and Apache Derby as the embedded database. Section 1. Before you start This tutorial is designed for developers who have found Java frameworks, such as Struts, lacking in needed functionality. If you're interested in developing Web applications in a more object-oriented manner, where the view is clearly separated from logic and there's minimal configuration and mapping, then Wicket is for you! This tutorial walks you through the basics of how Wicket works, while using Apache Geronimo to set up a Java Platform, Enterprise Edition (Java EE) server, Web server, and embedded database in just minutes. Combining Wicket with Geronimo lets you develop data-driven, scalable Web applications using software that's all open source. Develop a simple Web application with Apache Wicket and Apache Geronimo © Copyright IBM Corporation 1994, 2008.
    [Show full text]
  • Towards High-Quality Android Applications Development with Kotlin Bruno Gois Mateus
    Towards high-quality Android applications development with Kotlin Bruno Gois Mateus To cite this version: Bruno Gois Mateus. Towards high-quality Android applications development with Kotlin. Mobile Computing. Université Polytechnique Hauts-de-France, 2021. English. NNT : 2021UPHF0012. tel- 03247062 HAL Id: tel-03247062 https://tel.archives-ouvertes.fr/tel-03247062 Submitted on 2 Jun 2021 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. PhD Thesis Université Polytechnique Hauts-de-France and from INSA Hauts-de-France Subject: Computer Science Presented and defended by Bruno GÓIS MATEUS On March 26, 2021, Valenciennes Doctoral School: Sciences Pour l’Ingénieur (ED SPI 072) Research team, Laboratory: Département d’Informatique Laboratory of Industrial and Human Automation control, Mechanical engineering and Computer Science (LAMIH UMR CNRS 8201) Towards high-quality Android applications development with Kotlin JURY Committee President - Káthia MARÇAL DE OLIVEIRA. Professor at Université Polytechnique Hauts-de-France. Reviewers - Guilherme HORTA TRAVASSOS. Professor at Federal University of Rio de Janeiro. - Jacques KLEIN. Professor at University of Luxembourg. Examiner - Dalila TAMZALIT. Associate Professor at Université de Nantes. Supervisor - Christophe KOLSKI. Professor at Université Polytechnique Hauts-de-France. Co-Supervisor - Matias MARTINEZ.
    [Show full text]
  • Abstract Interface Behavior of an Object-Oriented Language with Futures and Promises
    Abstract interface behavior of an object-oriented language with futures and promises 3. September 2007 Erika Abrah´ am´ 1, and Immo Grabe2, and Andreas Gruner¨ 2, and Martin Steffen3 1 Albert-Ludwigs-University Freiburg, Germany 2 Christian-Albrechts-University Kiel, Germany 3 University of Oslo, Norway 1 Motivation How to marry concurrency and object-orientation has been a long-standing issue; see e.g., [2] for an early discussion of different design choices. Recently, the thread-based model of concurrency, prominently represented by languages like Java and C# has been criticized, especially in the context of component-based software development. As the word indicates, components are (software) artifacts intended for composition, i.e., open systems, interacting with a surrounding environment. To compare different concurrency models on a solid mathematical basis, a semantical description of the interface behavior is needed, and this is what we do in this work. We present an open semantics for a core of the Creol language [4,7], an object-oriented, concurrent language, featuring in particular asynchronous method calls and (since recently [5]) future-based concurrency. Futures and promises A future, very generally, represents a result yet to be computed. It acts as a proxy for, or reference to, the delayed result from a given sequential piece of code (e.g., a method or a function body in an object-oriented, resp. a functional setting). As the client of the delayed result can proceed its own execution until it actually needs the result, futures provide a natural, lightweight, and (in a functional setting) transparent mechanism to introduce parallelism into a language.
    [Show full text]