<p>The main goal of this thesis is the creation o f the tool agent-oriented programming tool AJA. AJA is the acronym for Adaptable Java Agents. AJA consists o f two programming languages:<br />- A higher-level language used for the description of the main agent parts. This language is called HADL, which is the acronym for Higher Agent Definition Language.<br />- A lower-level language used for the programming o f the agent parts defined in HADL. This language is called Java+. It is actually Java enriched with the constructs for accessing higher-level agent parts defined in HADL.<br />A translator from AJA to Java is implemented in the practical part o f the thesis. AJA agents have the following features: - Agent communicates with other agents using a construct called negotiation. The messages sent can be encrypted or digitally signed in order to ensure the security of the system. - Agent possesses adaptable&nbsp; parameters and neural nets that adapt themselves when the environment changes.<br />- Agent has reflexes, which are the reactive component o f the agent architecture.<br />- Agent can perform its actions parallel. Actions execution is synchronized.<br />- Agent is accessible via Internet, because it acts as a simple HTTP server. People can use this way to communicate with an agent.<br />- Agent has Java Swing based graphical user interface. Its owner uses this interface to communicate with the agent.<br />- Because o f the fact that Java-i- language extends Java, it is possible to use all useful Java features in the implementation o f AJA agents (e.g. JDBC for the database access). The thesis also presents an original approach of integrating artificial intelligence techniques, such as neural nets, with a programming language. Having the artificial intelligence components as a part of the programming language runtime environment makes their use straightforward. A programmer uses the language constructs that are implemented using the artificial intelligence<br />without the need for understanding their background and theory.<br />The thesis contains eight chapters and three appendixes. In the first chapter, an overview of agents and multi-agent systems is given. The second chapter surveys existing agent-oriented programming languages and tools. The third chapter introduces AJA and describes the architecture of AJA agents. The syntax and semantics o f AJA languages HADL and Java+ is described in the fourth chapter. The fifth chapter presents adaptable AJA constructs in more details. To demonstrate and test the created tool, a case-study multi-agent system has been implemented in AJA. There are four personal digital assistant agents in the system. The sixth chapter describes the example agents and positively evaluates the tool. In the seventh chapter the related work and tools are analyzed and compared to AJA. The last chapter concludes the thesis. The first appendix describes the implementation details of the AJA to Java translator. The second appendix is a guide for the installation and usage of the implemented AJA to Java translator. Finally, the third<br />appendix describes step by step how to translate, compile, run, and use the example agents. The thesis contains many references, which include almost all the most important and the most actual papers in the field. The reference list can be found at the end o f the thesis.</p> / <p>Glavni doprinos doktorske teze je napravljeni alat za programiranje agenata AJA . AJA - Adaptabilni Java Agenti je jezički alat za programsku implementaciju agenata Sastoji se od dva programska jezika:<br />- Jezik vi&scaron;eg nivoa kojim se opisuju glavne kom ponente agenta. Ovaj jezik se naziva HADL - Higher Agent Definition Language.<br />- Jezik nižeg nivoa koji služi za implementaciju pojedinih komponenti agenta specificiranih HADL jezikom . Ovaj jezik se najava Java+, jer je on zapravo programski jezik Java obogaćen konstrukcijama pomoću kojih je moguće pristupati komponentama agenta, definisanim u jezik u HADL.<br />AJA agent poseduje sledeće osobine:<br />- Sigurna kom unikacija sa drugim A JA agentim a koristeći mehanizam pregovaranja, &scaron;ifrovanje i digitalno potpisivanje poruka.<br />- Mogućnost adaptiranja na promene u okruženju u kom se nalazi, koristeći neuralne mreže i adaptabilne parametre.<br />- Reaktivnost zasnovana n a kom ponenti zvanoj refleks.<br />- Paralelno izvr&scaron;avanje akcija agenta u z njihovu internu sinhronizaciju.<br />- D ostupnost agenta preko Interneta. Agent se pona&scaron;a kao jednostavan HTTP server. Na ovaj način se drugim osobama omogućuje da komuniciraju sa agentom .<br />- G rafički korisnički interfejs zasnovan n a Java Swing tehnologiji<br />- Po&scaron;to se u program iranju agenta koristi Java+, moguće je uposliti sve pogodnosti Jave, kao &scaron;to su na primer pristup bazama podataka koristeći JDBC , rad sa multimedijalnim sadržajem , itd.<br />U tezi je predstavljen i originalni pristup integrisanja tehnika ve&scaron;tačke inteligencije sa program skim jezikom . U građujući kom ponente ve&scaron;tačke inteligencije u izvr&scaron;nu okolinu je z ik a čini n jihovo kori&scaron;ćenje veom a jednostavnim . Programer ne mora da bude ekspert iz ve&scaron;tačke inteligencije a da pri tome koristi konstrukcije jezika koje su implementirane pomoću ve&scaron;tačke inteligencije. AJA specifikacija agenta se sastoji od HADL i Java+ delova. U tezi je implementiran prevodioc kojim se A JA specifikacija prevodi u skup klasa programskog jezika Java. Implementiran je i jedan multi-agentski sistem kojim se praktično pokazuje kori&scaron;ćenje i mogućnosti napravljenog alata D oktorska teza sadrži i detaljan pregled oblasti o agentskpj m etodologiji. O n a kruni&scaron;e vi&scaron;egodi&scaron;nji rad kandidata i njegovog mentora u ovoj sve značajnijoj oblasti računarstva.<br />Teza sadrži o sam glava i tri dodatka. U prvoj glavi se opisuje oblast agenata i m ulti-agentskih sistem a. Pregled postojećih agentskih program skih jezik a i alata se daje u drugoj glavi. O pis A JA agenata i njihove arhitekture je dat u trećoj glavi teze. Četvrta glava se bavi sintaksom i sem antikom oba A JA jezika: H A D L -a i Jave+. Adaptabilni elem enti A JA agenata se opisuju u petoj glavi. U &scaron;estoj glavi je opisan m ulti-agentski sistem koji j e ujed n o i prim er prim ene A JA alata. A JA se sa drugim postojećim agentskim alatim a upoređuje u sedm oj glavi. Osma glava sadrži zaključak. N a kraju se u tri dodatka detaljno opisuju im plem entacija prevodioca A JA -e u Javu, instalacija prevodioca i kori&scaron;ćenje napravljenog m ulti-agentskog sistema respektivno. U doktorskom radu su kori&scaron;ćene i navedene brojne reference kojim a su obuhvaćeni gotovo svi najznačajniji i najaktuelniji radovi iz oblasti multi-agentskih sistema. Lista referenci je navedena na kraju teze.</p>

With the rise of modern programming languages like Java that include native support for multi-threading, the issue of concurrency in graphical applications becomes more and more important. Traditional graphical component libraries for Java have always used the threading concepts provided by the language very carefully, telling the programmer that the use of threads in this context is often unnecessarily burdensome and complex. On the other hand, experience gained from systems like Inferno or BeOS shows that the use of concurrency in graphical applications is clearly manageable and leads to a different program design, once you dissociate the application from the limitations of the GUI library. This thesis describes the design of a general architecture that allows for the separation of a program´s user interface from the application logic using thread communication. It enables the use of concurrency in the application code without requiring any degree of thread-safety at the native interface component level.

As the field of computer science continues to grow, the number of students enrolled in related programs will grow as well. Though one-on-one tutoring is one of the more effective means of teaching, computer science instructors will have less and less time to devote to individual students. To address this growing concern, many tools that automate parts of an instructor’s job have been proposed. These tools can assist instructors in presenting concepts and grading student work, and they can help students learn to program more effectively. A growing group of intelligent tutoring systems attempts to tie all of this functionality into a single tool that is meant to be used throughout an entire CS course or series of courses. To contribute to this emerging area, the Factoring Problem Generator (FPG) is presented in this work. The FPG creates and grades problems in C in which students search for and extract blocks of repeated code into individual functions, learning to utilize parameters and return values as they do so. The problems created by the FPG are highly configurable by instructors such that the difficulty can be finely tuned to suit students’ individual needs. Instructors can choose whether or not to include arrays, pointers, certain elemental data types, certain operators, or certain kinds of statements, among other things. The FPG is additionally capable of generating a set of test cases for each generated problem. These test cases fully exercise students’ solutions by covering all branches of execution, and they ensure that program functionality does not change as students factor code into functions. Initial experimentation with the system has suggested that the FPG can be integrated into a beginning CS curriculum and with further refinement could become a standard tool in the CS classroom.

In an effort to increase both the quality of software applications and the efficiency with which applications can be written, developers often incorporate multiple programming languages into software projects. Although language specialization arguably introduces benefits, the total impact of the resulting language fragmentation (working concurrently in multiple programming languages) on developer performance is unclear. For instance, developers may solve problems more efficiently when they have multiple language paradigms at their disposal. However, the overhead of maintaining efficiency in more than one language may outweigh those benefits. This thesis represents a first step toward understanding the relationship between language fragmentation and programmer productivity. We address that relationship within two different contexts: 1) the individual developer, and 2) the overall project. Using a data-centered approach, we 1) develop metrics for measuring productivity and language fragmentation, 2) select data suitable for calculating the needed metrics, 3) develop and validate statistical models that isolate the correlation between language fragmentation and individual programmer productivity, 4) develop additional methods to mitigate threats to validity within the developer context, and 5) explore limitations that need to be addressed in future work for effective analysis of language fragmentation within the project context using the SourceForge data set. Finally, we demonstrate that within the open source software development community, SourceForge, language fragmentation is negatively correlated with individual programmer productivity.

JavaScript has in recent years become one of the most utilized programming languages for developing different kinds of applications. However, even though it has received a lot of praise for its simplicity, versatility and highly active community, it lacks some functionalities and features that a lot of programmers highly value, like static and strict typing, compile-time debugging, and to not be required to make use of third-party libraries to integrate crucial functionality. However, several new languages built on top of JavaScript have been developed to address and resolve these issues developers find with JavaScript without losing the benefits that come with it. One of these super- set languages is Reason, the new syntax and toolchain powered by the OCaml compiler. This thesis aims to address whether there are scenarios where Reason could act as a reasonable substitute of JavaScript by investigating how the languages compare in regards to different criteria. The criteria examined are writability, data structures and typing, reliability and testing, community support, market demand, portability, and performance. The findings show that using Reason over JavaScript could result in higher reliability and robustness due to static type checking, compile-time debugging, and other usable feature like pattern matching and explicitly defined custom data structures, which is convenient when dealing with advanced data. On the other hand, Reason’s interoperability with JavaScript is something that is not very straight-forward and makes it difficult to integrate Reason into an existing JavaScript codebase or include one of the thousand of JavaScript- written dependencies available on npm. Furthermore, with Reason being a rather young language yet to be used by a larger audience, both the community support and market demand are a lot smaller than that of JavaScript and have yet to see a significant growth, which leads to questions about the overall survival of the language. Both of the languages have a significant role and contribute with different kind of functionality. However, with the non-straightforward interoperability, Reason loses a lot of potential benefits to be gained from JavaScript, which could be problematic in the long run and could impact the future of Reason. / JavaScript har under senare år blivit ett av de mest använda programmeringsspråken för att utveckla olika typer av applikationer. Men även om det har fått mycket beröm för sin enkelhet, mångsidighet och mycket aktivt nätgemenskap, saknar det vissa funktioner och egenskaper som många programmerare uppskattar mycket, som statisk och strikt typning, felsökning under kompilering och att inte vara I behov av tredjepartsbibliotek för att integrera grundläggande funktionalitet. Flera nya språk som är byggda ovanpå JavaScript har utvecklats för att lösa de problem som utvecklare har med JavaScript, utan att förlora fördelarna med det. Ett av dessa supersetsspråk är Reason, den nya syntaxen och verktygskedjan som drivs av OCaml-kompilatorn. Denna avhandling syfte är att utvärdera om det finns scenarier där Reason kan fungera som en rimlig ersättare för JavaScript, detta kommer genomföras genom att undersöka hur språken jämförs med varandra med avseende på olika kriterier. Kriterierna som undersöks är skrivbarhet, datastrukturer och typning, tillförlitlighet och testning, nätgemenskap, marknadsförfrågan, portabilitet, och prestanda. Resultaten visar att användning av Reason över JavaScript kan leda till högre tillförlitlighet på grund av statisk typkontroll, felsökning under kompilering och andra användbara funktioner som mönstermatchning och anpassade datastrukturer, båda underlättar vid hantering avancerade och komplexa datastrukturer. Däremot är Reasons kompabilitet med JavaScript komplicerad, vilket gör det svårt att integrera Reason i en befintlig JavaScript- kodbas eller inkludera ett av de tusentals JavaScript-skrivna biblioteken som finns tillgängliga på npm. Eftersom Reason är ett ganska ungt språk som ännu inte används på en större skala, så är både nätgemenskapen och marknadens efterfrågan mycket mindre än JavaScript och har ännu inte sett en betydande tillväxt, vilket leder till frågor om den långsiktiga överlevnaden av språket. Båda språken har en betydande roll och bidrar med olika slags funktioner. Men med den komplicerade kompatibiliteten med JavaScript så förlorar Reason en hel del potentiella fördelar som kan uppnås genom JavaScript, vilket kan vara problematiskt på lång sikt och kan påverka Reasons framtid.

Massively parallel programming is an increasingly growing field with the recent introduction of general purpose GPU computing. Modern graphics processors from NVIDIA and AMD have massively parallel architectures that can be used for such applications as 3D rendering, financial analysis, physics simulations, and biomedical analysis. These massively parallel systems are exposed to programmers through in- terfaces such as NVIDIAs CUDA, OpenCL, and Microsofts C++ AMP. These frame- works expose functionality using primarily either C or C++. In order to use these massively parallel frameworks, programs being implemented must be run on machines equipped with massively parallel hardware. These requirements limit the flexibility of new massively parallel systems. This paper explores the possibility that massively parallel systems can be exposed through web services in order to facilitate using these architectures from remote systems written in other languages. To explore this possi- bility, an architecture is put forth with requirements and high level design for building a web service that can overcome limitations of existing tools and frameworks. The CUDA Web API is built using Python, PyCUDA, NumPy, JSON, and Django to meet the requirements set forth. Additionaly, a client application, CUDA Cloud, is built and serves as an example web service client. The CUDA Web API’s performance and its functionality is validated using a common matrix multiplication algorithm implemented using different languages and tools. Performance tests show runtime improvements for larger datasets using the CUDA Web API for remote CUDA kernel execution over serial implementations. This paper concludes that existing limitations associated with GPGPU usage can be overcome with the specified architecture.

Sedentary behavior is linked to numerous adverse effects on a person’s health, such as obesity, depression, and a higher risk of cardiovascular events. Professions that are primarily sedentary have increased due to the growth of office-related occupations, one of which is software engineering. A potential intervention to reduce sedentary behavior is to utilize new interactive technologies such as virtual reality (VR) to change the work context and allow software engineers to interact with their work environment in a more embodied manner. This study has designed and evaluated a visual programming language (VPL) in VR for its potential to reduce sedentary behavior and its compromise on usability. Ten participants solving simple programming tasks using the VPL in VR revealed the potential of reducing continuous sedentary behavior with light physical activity. The main contributor to this activity was the need to walk to and from interactive elements placed a few meters from each other in the design. However, the usability evaluation showed that users modify the environment over time to reduce this distance such that less walking is needed. In contrast, movement induced by navigating to code blocks and getting an overview of the current state of the work had positive marks and a high contribution to the observed movement. Lastly, the second contributor to physical activity was moving blocks around. The usability evaluation indicates that using VR controllers was slower than using a mouse but allowed more precise interactions. / Stillasittande beteende har ett flertal negativa effekter på en persons hälsa, såsom obesitas, depression och en högre risk för kardiovaskulära händelser. Yrken som främst är stillasittande har ökat på grund av tillväxten av yrken som är kontorsbaserade, till exempel mjukvaruutveckling. Ett potentiellt ingripande för att minska stillasittande beteende är att använda nya interaktiva tekniker, så som virtuell verklighet (VR) för att förändra arbets kontexten och låta mjukvaruingenjörer interagera med sin arbetsmiljö på ett mer förkroppsligat sätt. Denna studie har utvecklat och utvärderat en visuellt programmeringsspråk (VPL) i VR för dess potential att minska stillasittande beteende och dess kompromiss på användbarhet. Tio deltagare som löste enkla programmeringsuppgifter med hjälp av VPL i VR visade potentialen för att bryta upp stillasittande beteende med lätt fysisk aktivitet. Den främsta bidragsgivaren till den observerade aktivitet var behovet av att gå till och från interaktiva element placerade med några meter avstånd från varandra. Utvärderingen visade dock att användare modifierar miljön över tid för att minska detta avstånd så att man behöver gå mindre. Däremot hade rörelser när man behöver navigera till kodblock och få en överblick över arbetet positiva kommentarer och ett högt bidrag till den observerade aktiviteten. Slutligen var aktiviteten att flytta runt block den handling som bidrog näst mest till den observerade fysisk aktivitet. Utvärderingen av användbarheten indikerar att VR-kontroller var långsammare än att använda en mus men tillät mer tillförlitliga interaktioner.

No description available.

<p> </p> <p>Productive programmable accelerators, like GPUs, have been developed for generations to support programming features. The ever-increasing performance improves the usability of programming features on GPUs, and these programming features further ease the porting of code and data structure from CPU to GPU. However, GPU programming features, such as function call or runtime polymorphism, have not been well explored or optimized.</p> <p>I identify efficient and productive GPU programming as a potential area to exploit. Although many programming paradigms are well studied and efficiently supported on CPU architectures, their performance on novel accelerators, like GPUs, has never been studied, evaluated, and made perfect. For instance, programming with functions is a commonplace programming paradigm that shapes software programs with modularity and simplifies code with reusability. A large amount of work has been proposed to alleviate function calling overhead on CPUs, however, less paper talked about its deficiencies on GPUs. On the other hand, polymorphism amplifies an object’s behaviors at runtime. A body of work targets</p> <p>efficient polymorphism on CPUs, but no work has ever discussed this feature under GPU contexts.</p> <p><br></p> <p>In this dissertation, I discussed those two programming features on GPU architectures. First, I performed the first study to identify the deficiency of GPU polymorphism. I created micro-benchmarks to evaluate virtual function overhead in controlled settings and the first GPU polymorphic benchmark suite, ParaPoly, to investigate real-world scenarios. The micro-benchmarks indicated that the virtual function overhead is usually negligible but can</p> <p>cause up to a 7x slowdown. Virtual functions in ParaPoly show a geometric meaning of 77% overhead on GPUs compared to the function’s inlined version. Second, I proposed two novel techniques that determine an object’s type only by its address pointer to improve GPU polymorphism. The first technique, Coordinated Object</p> <p>Allocation and function Lookup (COAL) is a software-only technique that uses the object’s address to determine its type. The second technique, TypePointer, needs hardware modification to embed the object’s type information into its address pointer. COAL achieves 80%  and 6% improvements, and TypePointer achieves 90% and 12% over contemporary CUDA and our type-based SharedOA.</p> <p>Considering the growth of GPU programs, function calls become a pervasive paradigm to be consistently used on GPUs. I also identified the overhead of excessive register spilling with function calls on GPU. To diminish this cost, I proposed a novel Massively Multithreaded Register Windowing technique with Variable Size Register Window and Register-Conscious Warp Scheduling. Our techniques improve the representative workloads with a geometric</p> <p>mean of 1.18x with only 1.8% hardware storage overhead.</p>

<p> </p> <p>Moore’s law is dead. The physical and economic principles that enabled an exponential rise in transistors per chip have reached their breaking point. As a result, High-Performance Computing (HPC) domain and cloud data centers are encountering significant energy, cost, and environmental hurdles that have led them to embrace custom hardware/software solutions. Single Instruction Multiple Thread (SIMT) accelerators, like Graphics Processing Units (GPUs), are compelling solutions to achieve considerable energy efficiency while still preserving programmability in the twilight of Moore’s Law.</p> <p>In the HPC and Deep Learning (DL) domain, the death of single-chip GPU performance scaling will usher in a renaissance in multi-chip Non-Uniform Memory Access (NUMA) scaling. Advances in silicon interposers and other inter-chip signaling technology will enable single-package systems, composed of multiple chiplets that continue to scale even as per-chip transistors do not. Given this evolving, massively parallel NUMA landscape, the placement of data on each chiplet, or discrete GPU card, and the scheduling of the threads that use that data is a critical factor in system performance and power consumption.</p> <p>Aside from the supercomputer space, general-purpose compute units are still the main driver of data center’s total cost of ownership (TCO). CPUs consume 60% of the total data center power budget, half of which comes from the CPU pipeline’s frontend. Coupled with the hardware efficiency crisis is an increased desire for programmer productivity, flexible scalability, and nimble software updates that have led to the rise of software microservices. Consequently, single servers are now packed with many threads executing the same, relatively small task on different data.</p> <p>In this dissertation, I discuss these new paradigm shifts, addressing the following concerns: (1) how do we overcome the non-uniform memory access overhead for next-generation multi-chiplet GPUs in the era of DL-driven workloads?; (2) how can we improve the energy efficiency of data center’s CPUs in the light of microservices evolution and request similarity?; and (3) how to study such rapidly-evolving systems with an accurate and extensible SIMT performance modeling?</p>