Scala

We present ScalaCollider, a new client framework to connect to the SuperCollider sound synthesis server. It builds on top of the general purpose language Scala. Scala’s ambition is to allow for the development of scalable systems, being equally comfortable both for small-scale scripting and large-scale modular projects.
Following an overview and comparison of the currently available clients for SuperCollider, we introduce the most important features of Scala, and show how its specific language elements can be exploited to design an elegant client that supports UGen graph composition, handles proxy objects, and restores part of the clarity lost in the entanglement of the original Super- Collider client’s class library.
The problems of type-safety and approaches to concurrency are discussed, and an outlook on a high-level extension for declarative sound process specification is given.

Scala is a general-purpose programming language designed to express common programming
patterns in a concise, elegant, and type-safe way. It smoothly integrates features
of object-oriented and functional programming languages, enabling
programmers to be more productive. Martin Odersky (the creator of Scala) and his
team started development on Scala in 2001 in the programming methods laboratory
at EPFL (École Polytechnique Fédérale de Lausanne). Scala made its public debut in
January 2004 on the JVM platform and a few months later on the .NET platform.
Even though Scala is fairly new in the language space, it has gained the support of
the programming community, which is growing every day. Scala is a rich language in
terms of features available to programmers, so without wasting time let’s dive into
some of them.
SCALA ON .NET At present Scala’s support for .NET isn’t stable. According to
the Scala language website (www.scala-lang.org), the current Scala distribution
can compile programs for the .NET platform, but a few libraries aren’t
supported. The main difficulty to overcome is that Scala programs make
heavy use of the Java JDK, which is not available out of the box in the .Net platform.
To overcome this issue, the current strategy is to use IKVM
(www.ikvm.net), which allows Java programs to convert to MSIL and the .NET
library.3 In this book I mainly focus on Scala for the JVM. The examples in this
book are tested only on a JVM.

( Alternatif Link download Buku Analisis Big Data: http://bit.ly/2x8ta9S )

Alhamdulillahhi robbil alamin, puji syukur kehadirat Allah SWT atas segala rahmat dan karunia-Nya dengan terselesaikannya penulisan buku ini dengan judul “Analisis Big Data”. Buku ini merupakan uraian untuk memudahkan pemahaman konsep, tingkat dasar sampai lanjut dalam sistem cerdas dan penerapannya melalui pemanfaatan teknologi Big Data, dengan mengedepankan keterampilan dalam pembuatan dan hasil implementasi dengan berbagai kombinasi algoritma berbasis sistem cerdas maupun dengan perpaduan berbagai macam tools untuk membangun ekosistem analisis Big Data yang powerfull. Konsep sederhana Analisis Big Data mencakup Volume, Velocity, dan Variety (3V), dan pengembangannya ada yang menyebut (7V) termasuk Volume, Velocity, Variety, Variability, Veracity, Value dan Visualization, atau 10V bahkan lebih dari itu, tetapi sebaiknya tidak membatasi pemahaman Big Data ini hanya dengan sedikit banyaknya istilah dari huruf V yang digunakan :). Kemudian dengan adanya ekosistem tersebut, jika dibutuhkan analisis sederhana maupun yang lebih kompleks, maka harapannya tidak akan ada kendala dari besarnya data yang diolah. Adanya kemajuan teknologi dalam hal penyimpanan, pengolahan, dan analisis Big Data meliputi (a) penurunan secara cepat terhadap biaya penyimpanan data dalam beberapa tahun terakhir; (b) fleksibilitas dan efektivitas biaya pada pusat data dan komputasi awan untuk perhitungan dengan konsep elastisitas dan penyimpanannya; serta (c) pengembangan kerangka kerja baru seperti Hadoop ecosystem (salah satu peluang bisnis yang besar untuk developer untuk saat ini dan ke depannya dalam rangka membangun ekosistem analisis Big Data yang sangat powerfull sekelas Cloudera, Hortonworks, etc), yang memungkinkan pengguna untuk mengambil manfaat dari sistem komputasi terdistribusi, misal untuk menyimpan sejumlah data yang besar melalui pemrosesan parallel, dukungan database NoSQL, dan komputasi berbasis streaming. Sehingga kemajuan teknologi ini telah menciptakan beberapa perbedaan yang sangat signifikan, misal dalam hal kecepatan maupun ketepatan dari hasil yang didapatkan antara analisis tradisional dengan tools yang bukan dengan konsep Big Data versus analisis modern untuk saat ini dan masa depan dengan membangun ekosistem Big Data yang sangat powerfull.
Penulis mengucapkan terimakasih yang sebesar-besarnya kepada kedua orang tua penulis, spesial kepada Istriku tercinta “Alfun Lailatul Musabbikha”, bapak ibu mertua, dik Wiwik, dik Ganda, kak Mat, kak Deri, Bude Gi, Pakde Dul, Bude Gani, Pak Abu, mbak Nik, dik Andre, Mbak As, Mbak Lia, Mas Mualif, Mbak Lis, Pakde Naji, Bulik Yul, Pakde Tasrun, Pakde Zen, Pakde Zud, Paklik Fiq, mas Bowo dan semua sanak saudaraku yang tak bisa kusebutkan seluruhnya, serta beberapa pihak yang telah membantu penyelesaian buku ini:
1. Para penulis artikel Analisis Big Data di forum, web, blog dan buku yang menjadi referensi buku ini untuk memberikan masukan yang sangat berharga sekali untuk perbaikan dan penyelesaian buku ini.
2. Mbak Efi Riyandani, yang telah banyak membantu penulisan buku, dan mahasiswa-mahasiswa terbaik saya semester Ganjil 2016/2017, yaitu: Maryamah, Moh. Fadel Asikin, Daisy Kurniawaty, Selly Kurnia Sari, Nanda Agung Putra, Ardisa Tamara Putri, Dhimas Anjar Prabowo, Listiya Surtiningsih, Raissa Arniantya, Brillian Aristyo Rahadian, Diva Kurnianingtyas, Dyan Putri Mahardika, Tusty Nadia Maghfira.
3. Mahasiswa-mahasiswa terbaik saya semester Ganjil 2017/2018, yaitu: Yessica Inggir F., Kholifaul K., Ni Made Gita D. P., Ema Agasta, Retiana Fadma P. Sinaga, Fachrul Rozy Saputra Rangkuti, Yunita Dwi Alfiyanti, Dyah Ayu Wahyuning Dewi, Annisaa Amalia Safitri, Sarah Aditya Darmawan, Danastri Ramya Mehaninda, Eka Novita Shandra, Fakharuddin Farid Irfani, Rio Cahyo Anggono, Robih Dini, Yulia Kurniawati, Novirra Dwi Asri, Muhammad Vidi Mycharoka, Vania Nuraini Latifah, Olivia Bonita, Eka Miyahil Uyun, Cusen Mosabeth, Evilia Nur Harsanti, Ivarianti Sihaloho.

Semoga kontribusi kalian menjadi ilmu yang barokah dan bermanfaat. Aamiin. :). Tidak ada gading yang tak retak. Maka penulis memohon kritik dan saran untuk perbaikan dan penyempurnaan buku ini. In Syaa Allah pada edisi berikutnya, kami akan memberikan manualisasi Map Reduce, Spark, etc. dari setiap algoritma pada setiap contoh kasusnya. Selamat membaca buku ini dan semoga bermanfaat.

Malang, 19 Juli 2016-24 Mei 2018

Penulis

VPN access to a distributed system makes it possible to implement a VPN connection connecting a
remote user to a distributed LAN server by protecting the client's identity and the confidentiality of
the processed data. This distributed system provides the functionality of reducing the time of a heavy
data calculation and processing by linking the nodes that execute the distributed application tasks
for each of them. The work was designed by implementing the OpenVPN in the server's network
host machine for secure VPN connection, Apache Mesos for shared resource management and
Apache Spark for running applications. The mode of interaction between a client and the system is
via a web interface implemented in the server.

PDF di 36 pagine con le immagini (descritte e commentate) mostrate durante il Caffè Araldico n° 2, incontro su piattaforma Internet fra studiosi e appassionati - versione italiana o inglese (rivolgersi a: caffearaldico@gmail.com)
----------------------------------
36-page PDF with images (described and commented) shown during the Caffè Araldico n ° 2, meeting on Internet platform between scholars and enthusiasts –  Italian or English version (contact: caffearaldico@gmail.com)

Statistical computing in ecology evolves at a high speed, mainly because researchers have recognized the advantage of being able to design their algorithms according to their needs. The present paper introduces the implementation in Scala language of the k-Nearest Neighbors (kNN) classifier, which can be applied also on small datasets, a situation commonly encountered in ecological research, and discusses its possible role within a more complex learning pipeline for classification tasks.

Bitcoin is many times advertised as a tool for anonymity and privacy. However, the anonymity provided by the native Bitcoin protocol is weak and can be broken relatively easily by malicious entities.
  This project aims to show how to improve Bitcoin’s anonymity through the use of Mixing. The project involves implementing a Mixing service and analysing how strong the anonymity provided by the mixer is.
This essay aims to describe how to implement mixing protocols in the Bitcoin network using Scala as a programming language. Furthermore, this project will attempt to construct a protocol of the author’s own device that guarantees stronger anonymity. Deployment of anonymity analysis tools will also be carried out. The main areas covered in the dissertation include: 
  -An introduction to anonymity, the Bitcoin protocol and mixing protocols
  -Professional and ethical considerations concerning the project
  -Requirements analysis for the project
  -The methodology used to obtain results
  -How the mixing service was built and deployed
  -An analysis of the results obtained from the mixing service

The Java language, and more broadly, the JVM Platform (as a host for several languages like Scala, Clojure and JRuby) is slowly emerging as the data analysis platform of the future. However, it is quite surprising that so far, high performance graphics libraries for data visualizations are still lacking on the Java Platform. This causes serious impediments to the data analyst.

In this talk, we propose using the high-quality and proven Qt graphics library to visualize data from the JVM. Qt is fast, reliable, and available for almost all major platforms for which Java is.

Several advantages result from this choice. First, we are saved from re-inventing the wheel, since the graphics stack and low level programming of Qt need not be re-done. Next, the extensive library of Qt widgets can be used as controls for our plot objects. Finally, since the visualization is performed outside of the JVM, any crashes of the graphics system leave us unaffected.

Mit der Vorliegenden Arbeit wird eine modulare Domänenspezifisch Abfragesprache mithilfe der Programmiersprache Scala, nach dem Prinzip einer internen Domänenspezifisch Sprache, für das Babelfisch-Projekt entwickelt.  Mithilfe der Abfragesprache ist es möglich, Pfade aus einer versionierten Graphdatenbank zu extrahieren, welche ein bestimmtes Muster vorweisen. Die resultierenden Pfade können dann falls gewünscht in eine Tabelle transformiert werden. Für die Abfragen wird auf das Datenbankschema zurückgegriffen, wodurch die darin enthaltenen Domänenspezifischen Ausdrücke verwendet werden können. Die Abfragesprache ist modular aufgebaut, damit neue Funktionalität über Module hinzugefügt werden kann.

This article describes Scala's compilation technique of structural types for the JVM. The technique uses Java reflection and polymorphic inline caches. Performance measurements of this technique are presented and analysed. Further measurements compare Scala's reflective technique with the "generative" technique used by Whiteoak to compile structural types. The article ends with a comparison of reflective and generative techniques for compiling structural types. It concludes that generative techniques may, in specific cases, exhibit higher performances than reflective approaches, but that reflective techniques are easier to implement and have fewer restrictions.

We present an extension of Scala that supports constraint programming over bounded and unbounded domains. The resulting language, Kaplan, provides the benefits of constraint programming while preserving the existing features of Scala. Kaplan integrates constraint and imperative programming by using constraints as an advanced control structure; the developers use the monadic ’for’ construct to iterate over the solutions of constraints or branch on the existence of a solution. The constructs we introduce have simple semantics that can be understood as explicit enumeration of values, but are implemented more efficiently using symbolic reasoning. Kaplan programs can manipulate constraints at run-time, with the combined benefits of type-safe syntax trees and first-class functions. The language of constraints is a functional subset of Scala, supporting arbitrary recursive function definitions over algebraic data types, sets, maps, and integers. Our implementation runs on a platform combin...

The process of composition can be seen as sequence of manipulations on the material. In algorithmic composition, such sequences are prescribed through another set of sequences which yield the algorithm. In a realtime situation the sequences may be closely linked to the temporal sequence of the unfolding musical structure, but in general they form orthogonal temporal graphs on their own. We present a framework which can be used to model these temporal graphs. The framework is composed of layers, which—from low to high level—provide (1) database storage and software transactional memory with selectable temporal semantics, (2) the most prominent semantics being confluent persistence, in which the temporal traces are registered and can be combined, yielding a sort of structural feedback or recursion, and finally (3) an event and expression propagation system, which, when combined with confluent persistence, provides a hook to update dependent object graphs even when they were constructed in the future. This paper presents the implementation of this framework, and outlines how it can be combined with a realtime sound synthesis system.

A partire dalle illuminanti considerazioni formulate da Bernard Rudofsky a proposito del carattere polisemico che contraddistingue le scale dei centri storici umbri e che travalica la mera valenza funzionale di collegamento urbano, il contributo esplora la vocazione scenografica di due casi studio tanto singolari quanto emblematici: via dell'Arringo a Spoleto, che esprime la propria identità di teatro statico, e via Appia a Perugia, che incarna il ruolo di teatro dinamico.

The replacement graph method [1] of the IGS-LSGP [2] to generate Random Latin Squares (LSs) [3] was reengineered and rewritten in the Scala language [4]. A functional-style algorithm was used to express an originally stateful and imperative algorithm, that used classic control structures (" if " , " while " , " for ") and mutable variables. In this paper, the experience, advantages and drawbacks, and a comparison of the performance with the original algorithm is described.

Domain-specific programming is bound to play a central role in improving the productivity of writing software. This is because modern, intricate, general-purpose abstractions are rarely applicable directly to everyday programming. However, such abstractions can be used to encode domain-specific abstractions, so that the general-purpose language serves as a host in which domain-specific fragments are embedded. The benefit of traditional software engineering is maintained, while allowing writing software that integrates multiple domains. This thesis describes two such techniques in Scala –a modern language with functional and object-oriented features. The first allows embedding fragments of code with domain-specific syntax, which is weaved within the host language's own syntax so that it appears as being different. The second technique uses structural types to encode domain-specific correctness properties that object-oriented types cannot represent. An implementation of structural types in Scala is also described. The common characteristic of both techniques is that domain-specific properties are provided by a library relying only on general-purpose abstractions. However, the techniques also exemplify how certain embedding tasks rely on data that is available in the compiler but is then lost in statically-typed languages. General-purpose abstractions do not give access to this data, nor do traditional runtime reflection techniques; keeping all data is also impractical. This thesis describes two metaprogramming techniques whereby compiler data on code (code lifting) and types (manifests) can be requested by embedding libraries when needed. Compiler data is then available as literal values in the program. It further describes a metaprogramming framework that combine compiler data available in code with reflection. Its design is mirror-based, and allows a high degree of code sharing between the metaprogramming framework and the compiler.

Programming languages are not only useful to command computers, they also increasingly are a medium for human communication. I will use the framework of distributed cognition to discuss how knowledge is shared in a team of programmers and to show that computer code plays an important role in it. The resulting model of how programmers comprehend code suggests that common grounds play an important role in it. I propose two hypotheses concerning the means used by programmers to refer to common grounds from within their code. The hypotheses imply that modern languages, such as Scala, offer advantages as human communication mediums. I describe an experiment, using an eye-tracking device, that measures the performance of code comprehension. The hypotheses are tested by varying the degree of reference to common grounds.

Niedda longa fig fruits ( Ficus carica L.) were dried by dehumidification. Fruits were divided in two different size groups, and dried for 120 h (A) or 96 h (B) in a room (8.5 m 3 ), in which 30.5°C-32.0°C of temperature and 34-40% of relative humidity were held by a small dehumidifier (29 kg weight). The lots A and B reached respectively 79.3±0.88% and 69.6±4.74% of dry matter content, at the end of the process. Following drying, fruits were sprayed with a potassium sorbate solution, then film packaged in air or in modified atmosphere and transferred at 20 °C to simulate shelf life. Lot A fruits were the most similar for chemical composition to imported dried figs. However, neither lot A nor B substantially differed, after 3 months of shelf life, for external-total count of yeasts, moulds and bacteria from the purchased fruits. Thus, the combination between dehumidification and potassium-sorbate treatment may allow for safe dried figs to be obtained. Si riferisce su una prova di es...

A parametric model of the human scala tympani has been designed for use in a haptic-rendered computer simulation of cochlear implant surgery. It will be the first surgical simulator of this kind. A geometric model of the Scala Tympani has been derived from measured data for this purpose. The model is compared with two existing descriptions of the cochlear spiral. A first approximation of the basilar membrane is also produced. The structures are imported into a force-rendering software application for system development.

We describe a new algorithm SplitMix for an object-oriented and splittable pseudorandom number generator (PRNG) that is quite fast: 9 64-bit arithmetic/logical operations per 64 bits generated. A conventional linear PRNG object provides a generate method that returns one pseudorandom value and updates the state of the PRNG, but a splittable PRNG object also has a second operation, split , that replaces the original PRNG object with two (seemingly) independent PRNG objects, by creating and returning a new such object and updating the state of the original object. Splittable PRNG objects make it easy to organize the use of pseudorandom numbers in multithreaded programs structured using fork-join parallelism. No locking or synchronization is required (other than the usual memory fence immediately after object creation). Because the generate method has no loops or conditionals, it is suitable for SIMD or GPU implementation. We derive SplitMix from the DotMix algorithm of Leiserson, Scha...

The Javadoc paradigm for displaying API documentation to users is quite popular, with similar variants existing for many mainstream languages. However, two user interface design properties of Javadoc may reduce its utility when displaying documentation for APIs that make use of inheritance and parametric polymorphism. First, Javadoc does not show a flattened view of all members of a class or interface, but rather only those defined directly in the type. Second, and as a consequence, any methods whose types contain type parameters of a superclass will always be shown in the context of the superclass. That is, if the method C.m returns type T, subclasses of C will always see this parent signature, even if they instantiate T to a concrete type such as Integer. We show that this situation arises often in some libraries, and present the results of a study that measures the usability consequences of these two Javadoc design decisions. Our results show that a user interface that shows instantiated type parameters for members is preferred over one that presents type parameters in the Javadoc style.

Abstract. Programming languages are not only useful to command computers, they also increasingly are a medium for human communication. I will use the framework of distributed cognition to discuss how knowledge is shared in a team of programmers and to show that computer code plays an important role in it. The resulting model of how programmers comprehend code suggests that common grounds play an important role in it. I propose two hypotheses concerning the means used by programmers to refer to common grounds from ...

— Multi-agent system (MAS) simulation, a growing field within artificial intelligence, requires the creation of high-performance, parallel, and user-friendly simulation frameworks. The standard approach is to use threads and shared memory. The drawbacks of this approach are the common concurrency pitfalls of race conditions and performance loss due to synchronization. Our goal was to evaluate the feasibility of an alternate model of concurrency, actors. An actor can be thought of as a very lightweight thread that does not share memory with other threads, instead communicating only through message passing. Actors seem to be a natural fit for this task, since agents are concurrently processed objects that communicate with each other through message passing. We write an actor framework and an equivalent threaded framework in the modern object-functional JVM language Scala and compare their performance. We conclude that the actor model seems like a natural fit, but its performance is in...

Recent works in the context of large-scale adaptive systems, such as those based on opportunistic IoT-based applications , promote aggregate programming, a development approach for distributed systems in which the collectivity of devices is directly targeted, instead of individual ones. This makes the resulting behaviour highly insensitive to network size, density, and topology, and as such, intrinsically robust to failures and changes to working conditions (e.g., location of computational load, communication technology, and computational infrastructure). Most specifically, we argue that aggregate programming is particularly suitable for building models and simulations of complex large-scale reactive MASs. Accordingly, in this paper we describe SCAFI (Scala Fields), a Scala-based API and DSL for aggregate programming, and its integration with the ALCHEMIST simulator, and usage scenarios in the context of smart mobility.