Mobility becomes very important in distributed Computing. Thus, many works deal with process strong mobility, but few of them deal with mobility of shared objects. In this paper, we present a mobility approach based on source code transformation, which allows strong mobile processes to communicate via remote shared objects. This approach enables shared object strong mobility. We demonstrate how both strong mobile processes and strong mobile shared objects can migrate at the same time while maintaining consistency of the application execution. We implemented our approach on Java Threads, using Java RMI. The evaluation of execution times shows that the overhead is very small compared to the original execution time.
{"title":"A serialization based approach for strong mobility of shared object","authors":"Soumaya Marzouk, M. B. Jemaa, M. Jmaiel","doi":"10.1145/1294325.1294359","DOIUrl":"https://doi.org/10.1145/1294325.1294359","url":null,"abstract":"Mobility becomes very important in distributed Computing. Thus, many works deal with process strong mobility, but few of them deal with mobility of shared objects. In this paper, we present a mobility approach based on source code transformation, which allows strong mobile processes to communicate via remote shared objects. This approach enables shared object strong mobility. We demonstrate how both strong mobile processes and strong mobile shared objects can migrate at the same time while maintaining consistency of the application execution. We implemented our approach on Java Threads, using Java RMI. The evaluation of execution times shows that the overhead is very small compared to the original execution time.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"131265630","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
This paper presents Saburo, a Java toolkit that generates, from a single Java specification, Java Internet server implementations, together with their formal model that can be automatically checked using the model checker SPIN. This approach ensures the coherence between the Internet server behavior and the static verifications applied on its formal model. Moreover, the use of the Java language as a unique input specification should help the dissemination of formal verification techniques. To simplify the automatic abstraction of the formal model, the Saburo approach is based on the separation of concerns principle. The Java specification is decomposed into three parts: a concurrency model chosen among several predefined ones, a graph describing all the communication and synchronization, and the business code. This approach has two main advantages: the change of the concurrency model is straightforward, and the classical problem of state explosion induced by the automatic extraction of the formal model from the source code is minimized. This work blends together a set of features coming from server design, compilers, software engineering and formal verification. Even though we do not claim novelty in each of the techniques adopted for Saburo, they have been unified into our Java toolkit, which supports all server design phases.
{"title":"A Java toolkit for the design and the automatic checking of server architectures","authors":"G. Loyauté, R. Forax, G. Roussel","doi":"10.1145/1294325.1294341","DOIUrl":"https://doi.org/10.1145/1294325.1294341","url":null,"abstract":"This paper presents Saburo, a Java toolkit that generates, from a single Java specification, Java Internet server implementations, together with their formal model that can be automatically checked using the model checker SPIN. This approach ensures the coherence between the Internet server behavior and the static verifications applied on its formal model. Moreover, the use of the Java language as a unique input specification should help the dissemination of formal verification techniques.\u0000 To simplify the automatic abstraction of the formal model, the Saburo approach is based on the separation of concerns principle. The Java specification is decomposed into three parts: a concurrency model chosen among several predefined ones, a graph describing all the communication and synchronization, and the business code. This approach has two main advantages: the change of the concurrency model is straightforward, and the classical problem of state explosion induced by the automatic extraction of the formal model from the source code is minimized.\u0000 This work blends together a set of features coming from server design, compilers, software engineering and formal verification. Even though we do not claim novelty in each of the techniques adopted for Saburo, they have been unified into our Java toolkit, which supports all server design phases.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"181 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"114553919","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
ProVotE is a two-phase project aiming at actuating art. 84 of law 2 -- 5/3/2003 of the Autonomous Province of Trento (Italy), which promotes the introduction of e-voting systems for the next provincial elections in Trentino (Nov. 2008). During the first phase of the ProVotE project we built jprovote, a Java/Linux e-voting system. The jprovote system has been used with experimental value by more than 11000 voters during local elections held in various municipalities of Trentino (Italy). A critical component of jprovote is its core logic, that is responsible of controlling the overall behavior of the e-voting machine during an election. In order to simplify its development and to allow for formal verification of this critical component we developed FSMC+. FSMC+ is a compiler that takes as input a subset of UML Statecharts and produces the corresponding Java and NuSMV code (NuSMV is a model checker developed at ITC-irst). Support for parameters in events, complex expressions in guards, and support to nested states are some of the distinguishing features of FSMC+. In this paper we present FSMC+ and we show how we used it for the development and the verification of the ProVotE e-voting machine. Even though FSMC+ has been specifically created to ease the development of jprovote, we believe the approach and the tool we developed to be general enough to be used in other applications.
{"title":"FSMC+, a tool for the generation of Java code from statecharts","authors":"Roberto Tiella, Adolfo Villafiorita, Silvia Tomasi","doi":"10.1145/1294325.1294338","DOIUrl":"https://doi.org/10.1145/1294325.1294338","url":null,"abstract":"ProVotE is a two-phase project aiming at actuating art. 84 of law 2 -- 5/3/2003 of the Autonomous Province of Trento (Italy), which promotes the introduction of e-voting systems for the next provincial elections in Trentino (Nov. 2008).\u0000 During the first phase of the ProVotE project we built jprovote, a Java/Linux e-voting system. The jprovote system has been used with experimental value by more than 11000 voters during local elections held in various municipalities of Trentino (Italy).\u0000 A critical component of jprovote is its core logic, that is responsible of controlling the overall behavior of the e-voting machine during an election. In order to simplify its development and to allow for formal verification of this critical component we developed FSMC+.\u0000 FSMC+ is a compiler that takes as input a subset of UML Statecharts and produces the corresponding Java and NuSMV code (NuSMV is a model checker developed at ITC-irst). Support for parameters in events, complex expressions in guards, and support to nested states are some of the distinguishing features of FSMC+.\u0000 In this paper we present FSMC+ and we show how we used it for the development and the verification of the ProVotE e-voting machine. Even though FSMC+ has been specifically created to ease the development of jprovote, we believe the approach and the tool we developed to be general enough to be used in other applications.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"58 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"129551821","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
A future is a simple and elegant construct that programmers can use to identify potentially asynchronous computation and to introduce parallelism into serial programs. In its recent 5.0 release, Java provides an interface-based implementation of futures that enables users to encapsulate potentially asynchronous computation and to define their own execution engines for futures. In prior work, we have proposed an alternative model, called directive-based lazy futures (DBLFutures), to support futures in Java, that simplifies Java programmer effort and improves performance and scalability of future-based applications. In the DBLFuture model, programmers use a new directive, "@future", to specify potentially concurrent computations within a serial program. DBLFutures enable programmers to focus on the logic and correctness of a program in the serial version first, and then to introduce parallelism gradually and intuitively. Moreover, DBLFutures provide greater flexibility to the Java virtual machine for efficient future support. In this paper, we investigate the exception handling aspect of futures in Java. In Java 5.0 Future APIs, exceptions of future execution are propagated to the point in the program at which future values are queried (used). We show that this exception handling model is not appropriate or desirable for DBLFutures. Instead, we propose an as-if-serial exception handling mechanism for DBL-Futures in which the system delivers exceptions at the same point as they would be delivered if the program was executed sequentially. Our approach, we believe, provides programmers with intuitive exception handling behavior and control. We present the design and implementation of our approach within the DBLFuture framework in the Jikes Research Virtual Machine. Our results show that our implementation introduces negligible overhead for applications without exceptions, and guarantees serial semantics of exception handling for applications that throw exceptions.
{"title":"Supporting exception handling for futures in Java","authors":"Lingli Zhang, C. Krintz, P. Nagpurkar","doi":"10.1145/1294325.1294349","DOIUrl":"https://doi.org/10.1145/1294325.1294349","url":null,"abstract":"A future is a simple and elegant construct that programmers can use to identify potentially asynchronous computation and to introduce parallelism into serial programs. In its recent 5.0 release, Java provides an interface-based implementation of futures that enables users to encapsulate potentially asynchronous computation and to define their own execution engines for futures. In prior work, we have proposed an alternative model, called directive-based lazy futures (DBLFutures), to support futures in Java, that simplifies Java programmer effort and improves performance and scalability of future-based applications. In the DBLFuture model, programmers use a new directive, \"@future\", to specify potentially concurrent computations within a serial program. DBLFutures enable programmers to focus on the logic and correctness of a program in the serial version first, and then to introduce parallelism gradually and intuitively. Moreover, DBLFutures provide greater flexibility to the Java virtual machine for efficient future support.\u0000 In this paper, we investigate the exception handling aspect of futures in Java. In Java 5.0 Future APIs, exceptions of future execution are propagated to the point in the program at which future values are queried (used). We show that this exception handling model is not appropriate or desirable for DBLFutures. Instead, we propose an as-if-serial exception handling mechanism for DBL-Futures in which the system delivers exceptions at the same point as they would be delivered if the program was executed sequentially. Our approach, we believe, provides programmers with intuitive exception handling behavior and control. We present the design and implementation of our approach within the DBLFuture framework in the Jikes Research Virtual Machine. Our results show that our implementation introduces negligible overhead for applications without exceptions, and guarantees serial semantics of exception handling for applications that throw exceptions.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"48 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"117255212","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
The Spallation Neutron Source (SNS) is a state-of-the-art neutron scattering facility recently commissioned by the US Department of Energy (DOE). The neutron beam produced at SNS will have an intensity that is an order of magnitude higher than existing facilities worldwide, enabling a significantly better understanding of and exploration into the structure of matter. The SNS is a billion-and-a-half dollar investment supporting research that impacts diverse science domains such as materials, chemistry, engineering, polymers, structural biology, and superconductivity. Thousands of scientists from around the world will annually perform experiments at SNS, ultimately producing petabytes of raw data that must be reduced, curated, analyzed and visualized. The SNS facility is developing a Java-based one-stop shopping web portal with access to the broad spectrum of data and computing services that will facilitate scientific discovery by enabling geographically dispersed users to seamlessly access and utilize the SNS facility resources. In this article, we describe the design and implementation of the SNS portal, focusing on several key architectural components, highlighting the diverse usage of Java in a production environment, ranging from enterprise level software composition to remote interactive visualization and integration with high performance distributed computing.
{"title":"A Java-based science portal for neutron scattering experiments","authors":"Sudharshan S. Vazhkudai, J. Kohl, J. Schwidder","doi":"10.1145/1294325.1294329","DOIUrl":"https://doi.org/10.1145/1294325.1294329","url":null,"abstract":"The Spallation Neutron Source (SNS) is a state-of-the-art neutron scattering facility recently commissioned by the US Department of Energy (DOE). The neutron beam produced at SNS will have an intensity that is an order of magnitude higher than existing facilities worldwide, enabling a significantly better understanding of and exploration into the structure of matter. The SNS is a billion-and-a-half dollar investment supporting research that impacts diverse science domains such as materials, chemistry, engineering, polymers, structural biology, and superconductivity. Thousands of scientists from around the world will annually perform experiments at SNS, ultimately producing petabytes of raw data that must be reduced, curated, analyzed and visualized. The SNS facility is developing a Java-based one-stop shopping web portal with access to the broad spectrum of data and computing services that will facilitate scientific discovery by enabling geographically dispersed users to seamlessly access and utilize the SNS facility resources. In this article, we describe the design and implementation of the SNS portal, focusing on several key architectural components, highlighting the diverse usage of Java in a production environment, ranging from enterprise level software composition to remote interactive visualization and integration with high performance distributed computing.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"193 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"123345434","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Although object-oriented languages are nowadays the mainstream of application development, several research contexts suggest that a multi-paradigm approach is worth pursuing. In particular, a declarative, logic-based paradigm could fruitfully add functionalities related to automatic reasoning, adaptivity, and conciseness in expressing algorithms. In this paper we present P@J, a framework for enhancing interoperability between Java and Prolog based on the tuProlog open-source Prolog engine for Java. P@J supports smooth language-interoperability by first introducing an API for modeling first-order logic terms by Java generics and wildcards, promoting expressiveness and safety. On top of it, an annotation layer is then introduced that extends Java with the ability of implementing parts of the application code using Prolog.
{"title":"A Prolog-oriented extension of Java programming based on generics and annotations","authors":"Maurizio Cimadamore, Mirko Viroli","doi":"10.1145/1294325.1294352","DOIUrl":"https://doi.org/10.1145/1294325.1294352","url":null,"abstract":"Although object-oriented languages are nowadays the mainstream of application development, several research contexts suggest that a multi-paradigm approach is worth pursuing. In particular, a declarative, logic-based paradigm could fruitfully add functionalities related to automatic reasoning, adaptivity, and conciseness in expressing algorithms. In this paper we present P@J, a framework for enhancing interoperability between Java and Prolog based on the tuProlog open-source Prolog engine for Java. P@J supports smooth language-interoperability by first introducing an API for modeling first-order logic terms by Java generics and wildcards, promoting expressiveness and safety. On top of it, an annotation layer is then introduced that extends Java with the ability of implementing parts of the application code using Prolog.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"108 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"124234389","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
We present the Dynamic Theory Execution (DynamiTE) framework for creating concurrent object-oriented applications, with semantics grounded in a process calculus. DynamiTE allows a system to be constructed as a series of distinct mobile components called environs which can change position during execution, and between which individual processes can migrate.
我们提出了动态理论执行(Dynamic Theory Execution, DynamiTE)框架，用于创建并发的面向对象应用程序，其语义以进程演算为基础。DynamiTE允许将系统构建为一系列不同的移动组件，称为环境，可以在执行过程中改变位置，并且单个进程可以在其之间迁移。
{"title":"A framework for mobile Java applications","authors":"A. Hughes","doi":"10.1145/1294325.1294360","DOIUrl":"https://doi.org/10.1145/1294325.1294360","url":null,"abstract":"We present the Dynamic Theory Execution (DynamiTE) framework for creating concurrent object-oriented applications, with semantics grounded in a process calculus. DynamiTE allows a system to be constructed as a series of distinct mobile components called environs which can change position during execution, and between which individual processes can migrate.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"53 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"124281577","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Bytecode instrumentation is a valuable technique for transparently enhancing virtual execution environments for purposes such as monitoring or profiling. Current approaches to bytecode instrumentation either exclude some methods from instrumentation, severely restrict the ways certain methods may be instrumented, or require the use of native code. In this paper we compare different approaches to bytecode instrumentation in Java and come up with a novel instrumentation framework that goes beyond the aforementioned limitations. We evaluate our approach with an instrumentation for profiling which generates calling context trees of various platform-independent dynamic metrics.
{"title":"Advanced Java bytecode instrumentation","authors":"Walter Binder, J. Hulaas, Philippe Moret","doi":"10.1145/1294325.1294344","DOIUrl":"https://doi.org/10.1145/1294325.1294344","url":null,"abstract":"Bytecode instrumentation is a valuable technique for transparently enhancing virtual execution environments for purposes such as monitoring or profiling. Current approaches to bytecode instrumentation either exclude some methods from instrumentation, severely restrict the ways certain methods may be instrumented, or require the use of native code. In this paper we compare different approaches to bytecode instrumentation in Java and come up with a novel instrumentation framework that goes beyond the aforementioned limitations. We evaluate our approach with an instrumentation for profiling which generates calling context trees of various platform-independent dynamic metrics.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"32 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"127648991","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
More and more aspects of concurrency and concurrent programming are becoming part of mainstream programming and software engineering, as a result of several factors, such as the widespread availability of multi-core / parallel architectures and Internet-based systems. Java has been one of the first mainstream languages providing a first-class native support for multi-threading, with basic low-level fine-grained concurrency mechanisms, recently improved by means of the java.util.concurrent library provided in the JDK 5.0. Besides such a fine-grained support to concurrency, the identification of higher-level---more coarse-grained---support is important as soon as the programming and engineering of complex concurrent applications is considered, helping to bridge the gap between system design, implementation, or testing. Accordingly, in this paper we present simpA, a library-based extension of Java which aims at providing a high-level coarse-grained support to complex multithreaded / concurrent application programming, by providing Java programmers with an agent-oriented abstraction layer on top of the basic OO layer to organise and structure applications in terms of agents and artifacts.
{"title":"simpA: an agent-oriented approach for prototyping concurrent applications on top of Java","authors":"A. Ricci, Mirko Viroli","doi":"10.1145/1294325.1294350","DOIUrl":"https://doi.org/10.1145/1294325.1294350","url":null,"abstract":"More and more aspects of concurrency and concurrent programming are becoming part of mainstream programming and software engineering, as a result of several factors, such as the widespread availability of multi-core / parallel architectures and Internet-based systems. Java has been one of the first mainstream languages providing a first-class native support for multi-threading, with basic low-level fine-grained concurrency mechanisms, recently improved by means of the java.util.concurrent library provided in the JDK 5.0.\u0000 Besides such a fine-grained support to concurrency, the identification of higher-level---more coarse-grained---support is important as soon as the programming and engineering of complex concurrent applications is considered, helping to bridge the gap between system design, implementation, or testing. Accordingly, in this paper we present simpA, a library-based extension of Java which aims at providing a high-level coarse-grained support to complex multithreaded / concurrent application programming, by providing Java programmers with an agent-oriented abstraction layer on top of the basic OO layer to organise and structure applications in terms of agents and artifacts.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"4613 1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"127245802","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
M. A. Forment, Pablo Casado Arias, María José Casany Guerrero
Mobile distributed applications must be able to work offline when no network connection is available, or simply to spare bandwidth or money. To do so the mobile client must be able to store and handle structured data. Java 2 Micro Edition (J2ME) does not support neither object serialization nor relational table management. When most legacy systems still rely on database engines, it also seems that J2ME only considers the Webservices API as a tool to access data on the server side. No JDBC API is provided to send and retrieve data from the mobile device to the DBMS in the server. This paper presents an Open Source library for J2ME that implements a lightweight database engine that allows CDLC devices (such as the currently available mobile phones) to handle object serialization easily, SQL relational database management and JDBC, using SQL to access any DBMS in the mainframe.
{"title":"J2MEMicroDB: an open source distributed database engine for mobile applications","authors":"M. A. Forment, Pablo Casado Arias, María José Casany Guerrero","doi":"10.1145/1294325.1294358","DOIUrl":"https://doi.org/10.1145/1294325.1294358","url":null,"abstract":"Mobile distributed applications must be able to work offline when no network connection is available, or simply to spare bandwidth or money. To do so the mobile client must be able to store and handle structured data. Java 2 Micro Edition (J2ME) does not support neither object serialization nor relational table management. When most legacy systems still rely on database engines, it also seems that J2ME only considers the Webservices API as a tool to access data on the server side. No JDBC API is provided to send and retrieve data from the mobile device to the DBMS in the server.\u0000 This paper presents an Open Source library for J2ME that implements a lightweight database engine that allows CDLC devices (such as the currently available mobile phones) to handle object serialization easily, SQL relational database management and JDBC, using SQL to access any DBMS in the mainframe.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"15 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"127278093","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
京公网安备 11010802042870号
京ICP备2023020795号-1
扫码关注我们
求助内容：
应助结果提醒方式：