1194 research outputs found
Sort by
LLM Assisted Development
Get PDFA. Introduction
In recent years, Large Language Models (LLMs) have become valuable tools for developers with their ability to quickly scaffold code and act as an impactful accelerator for development teams around the world. With code being heavily standardized on a global scale and an abundance of training data freely available on platforms such as GitHub, it is easy to intuit possible reasons for their performance. While these assumptions hold true for popular languages such as Java, Python or C#, there has been little research in the usage of LLMs as development tools for less commonly used languages such as Haskell. With this project we aim to explore LLM based development support for Haskell and develop an environment, in which such research can be conducted in a quick and efficient manner.
B. Approach
Four stateoftheart models (Llama 2, Code Llama, GPT3.5 and GPT4) were evaluated based on their performance on tasks typically faced by an automated development support tool. The tasks were scoped and classified into three major categories:
Code Generation, Debugging and Testing. For each of these categories, quantifiable metrics for the evaluation of the model performance were defined. These criteria must be interpretable as quantifiable metrics to allow a comparative analysis between models. These metrics were then weighted according to their importance, based on the insight of experts in the field of Haskell development. Each task was executed with three sorting algorithms of varying cognitive complexity in sample implementations. Cognitive complexity was selected as the complexity measure after careful evaluation, to ensure that the ordering of the algorithms is based on complexity of interpretability. Utilizing cognitive complexity inspired us to frame LLMs as entities whose performance can be analysed through the lens of cognitive load theory. This enabled the differentiation between errors caused by the complexity of a provided algorithm (intrinsic load) and errors caused by unclear instructions (extraneous load). To accelerate the evaluation processes, a development environment, enabling both the automated testing of generated Haskell code using Jupyter notebooks and the utilization of cloud hosted models with modern LLM tooling like LangChain, was created.
C. Conclusion
Our work has shown that there are large gaps in output quality between each model. We have encountered outliers, but we are confident that these outliers were not caused by the intrinsic complexity of the algorithms provided and can be explained with extraneous complexity that lead to the model not understanding the task. This problem can be resolved with further prompt engineering and finetuning, which is why we are optimistic about the viability of models such as GPT4 or Code Llama as supporting tools for Haskell development. Using Chain of Thought Prompting, which leads models to break down given tasks into sequential subtasks, tends to increase the outputquality in general. However the sequential nature of it lead to inconsistencies in the compositions of Haskell’s higherorder functions. It lead the models to neglect critical nuances in function composition, resulting in erroneous code generation
What’s up in RJ
Get PDFThis project is about creating a simple-to-use web application that centralizes a list of events and organizers in the vicinity of Rapperswil-Jona. Its purpose is to present all kinds of fun, interesting and exciting events to the regional residents.
The application is built from scratch, there is no existing platform used as a base. With a centralized platform it is possible for organizers to easily publish their own events. Anyone can sign up as an organizer, making it appealing to all people and organizations looking to advertise their events. Users of the platform benefit from this by being able to find events advertised by regional, national, and even global organizers. After creating a user account, they can simply subscribe to the newsletter, delivered twice a month, informing them about new and upcoming events that match their preferences.
The approach is to create a web application consisting of a frontend, backend, and database layer. Deployed with a cloud hosting provider, the application is widely accessible to all users. Following the initial inception phase, the application underwent design and development during the elaboration phase. The implementation of the entire application was then done during the construction phase. Additionally, various tests were conducted, including usability tests with real end users to evaluate the user experience.
This first iteration is a good starting point to create a seamless platform where users and organizers are able to interact with each other. In future steps, it is recommended to implement additional features to increase the application's appeal. This project has considerable potential to become a successful platform for event organizers and attendees
Middleware-Plattform zur Harmonisierung von Smart Home- und IoT-Systemen
Get PDFDie zunehmende Digitalisierung und Vernetzung von Haushaltsgeräten hat zu einer Vielzahl proprietärer Smart Home- und IoT-Systemen von verschiedenen Herstellern geführt. Diese Vielfalt
stellt erhebliche Herausforderungen für Nutzer dar, die ein nahtloses und einheitliches Smart HomeErlebnis anstreben. Nutzer müssen oft verschiedene Apps und Plattformen verwenden, um ihre Geräte zu
steuern, was zu einer fragmentierten und ineffizienten Handhabung führt. Gleichzeitig stehen Entwickler von Geräteherstellern vor der Schwierigkeit, universelle Schnittstellen zu erstellen, die mit den
unterschiedlichen Kommunikationsprotokollen und Datenformaten der proprietären Systeme kompatibel sind. Inkompatibilitäten behindern die Schaffung einer kohärenten Benutzererfahrung und erschweren die Integration neuer Geräte und Funktionen
Design of a locomotive UI for system testing (SA)
No full textThis project presents a novel UI prototype for a locomotive testing system that specifically targets the driver's cab.
Starting from the cluttered and unstructured LabVIEW application, our goal was to design and develop a new application that was user-friendly and structured.
By aligning the structure with the real locomotive, the prototype aims to provide an intuitive user experience.
The resulting prototype takes a component-based approach and focuses on design, extensibility and modularization.
The design was developed with Figma and implemented using web technologies; more specifically an Electron application combined with React was implemented.
A key feature is the customization capability through a configuration file in CSV format, allowing flexible configuration of modules and variants.
To simulate the prospective interface connection, a mock-backend was created, as the actual backend implementation is pending.
This project provides a solid foundation for further development and demonstrates the possibilities of extending the application with additional views and functionality, ultimately serving as a valuable platform for ongoing work in this area
Network insights in OpenTelemetry
Get PDFThe complexity of modern applications demands comprehensive observability to pinpoint performance bottlenecks and optimize application performance. OpenTelemetry, a vendor-neutral observability framework, excels at capturing application-level insights, but the inclusion of network visibility is crucial. This thesis explores the integration of network telemetry data into OpenTelemetry, aiming to provide a holistic understanding of application performance and detect network-related issues.
The project successfully establishes the groundwork for incorporating network visibility into application monitoring using OpenTelemetry. The developed system is positioned for submission as an open-source project. Focusing on the network connecting a 3-tier application, the project ensures that the network path and associated latency are visible during the evaluation of application performance.
The achieved objectives include displaying individual network components, capturing ingress and egress timestamps, and seamlessly integrating network monitoring data into existing traces in OpenTelemetry. These enhancements empower the system to offer insights into latency, network component processing time, and their correlation with requests and existing traces.
Despite these accomplishments, the project falls short of fully identifying the reasons for latency. The selected data retrieval method, Netflow / IPFIX, lacks detailed information about the device's status, limiting the ability to precisely determine the causes of latency. Nevertheless, the project significantly advances observability in distributed applications, providing valuable troubleshooting and performance optimization insights.
Future enhancements could focus on capturing more detailed device status information to identify the root causes of latency better, thereby continuing the trajectory of improvement in observability within distributed applications
ChatGPT-3 Security Labs
Get PDFAI is currently a topic that is being addressed in most industries. This is no exception, especially for cybersecurity. Advantages could be realized, for example, in the automation of security analysis and thus in the relief of analysts. As is often the case, there are disadvantages here too. The use of AI makes it possible for a wide audience to achieve rapid success without in-depth knowledge.
The aim of the work is to research the effects of AI on cybersecurity. For this purpose, both the Blue Team side and the Red Team side are explored. Ultimately, the aim is to create labs that students can use to work on.
The topics were selected using a decision matrix with weights based on various criteria. This is intended to address the most relevant topics. A Proof of Concept (PoC) was then carried out for each selected topic. Topics have developed in the categories of reverse engineering, exploiting, threat modelling, phishing and prompt engineering.
In our research, we focused on prompt engineering, a recognized area in AI where control over the AI's output is consciously managed. Our experimentation revealed that retraining the AI through prompt engineering was facilitated more effectively using the OpenAI API, which allows the provision of "system content" to influence the AI's behaviour. Utilizing DAN as system content in our Hacking Lab, we successfully conducted various experiments, making potentially malicious requests to the AI without encountering blocking mechanisms. Our results, illustrated in the evaluated labs, showcase the efficacy of prompt engineering in achieving desired outcomes
Order Management Tool für 3D-Druck Dienstleistungen
Get PDFWhen a startup is founded, the focus is
usually put on getting orders instead of implementing
an adequate order management solution.
As the startup grows in orders and employees, the
initial make-do solution may become insufficient and
slow the business down in the long run. This was the
case for our partners Change 3D, who provide
various services in the 3D-printing environment. Their
make-do solution consisted of printing out cards for
each order. The printed cards were then filled in with
details such as order number, title, and client name,
and ultimately hung on a whiteboard.
As their business grew, the whiteboard became too
full, making it more difficult to find orders and keep up
with deadlines. This challenge led to the realization
that a new solution is needed.
To solve the problems and
alleviate the pain points of our partner, we set out to
develop a tool that displays their orders on a kanban
board. In close collaboration with our partners, we
followed the principles of user-centered design that
enforces an iterative process and focuses on an
understanding of the users and their context in all
stages. This enabled us to gain a deep understanding
of their problem and allowed us to build an application
tailored to their needs. Through a scheduler, written
as a microservice in Kotlin, we integrated their Bexio
where we fetch the orders from, to eliminate the
necessity of manually creating an item for the board.
The core of the application is a backend written in
Kotlin, which receives the orders from the scheduler
and stores them in a MongoDB. Additionally, the
states and state transitions are managed in the
backend, which automatically triggers actions on
Bexio, further eliminating manual steps of the
previous process. The frontend is written in Angular,
communicating with the backend through a RESTful
API, which allows for live updating using SSE.
The result provides a substantive
improvement for the day-to-day business and order
management of our partner, as determined by user
tests. The core functionality is the board, which
responsively displays the items in columns
representing the states. Through drag and drop, an
item can be moved into another state, which triggers
the applicable action on Bexio. To improve the
usability of the board and make it more practical for
more use cases, there are various view options
implemented, such as sorting, filtering, and grouping
the items. On top of that, what is shown on each card
is configurable and pieces of information can be
hidden to further remove clutter from the board.
Additional information can be stored and found on the
detailed view of each card, such as assigning the item
to someone, the history of the item, or an interactive
3D render of the piece that is being produced. After
an item has gone through all the steps and the order
is completed, it can be moved into the archive, which
provides an insight into the orders that were
completed across a timeline
Green Networking - Visibility, a first step towards sustainable networking
Get PDFThis thesis is a follow-up project to our term paper that proposed green networking metrics aimed at enhancing the energy efficiency of networking infrastructures.
The initial study highlighted the lack of visibility into network energy efficiency, which hampers efforts to optimize sustainability.
The primary objective of this thesis is to demonstrate a comprehensive use case in a virtualized environment where the energy efficiency indicators, developed in the earlier study, are exported and visualized.
This aims to provide network operators with the tools necessary to improve network efficiency.
The research involves setting up a proof of concept within a simulated network environment.
This includes implementing an IPFIX exporter on network switches to gather efficiency data, establishing collecting servers for persistent storage of this information, and creating dashboards to visualize the network's current state.
Additionally, an automation solution is implemented to dynamically configure and update the simulation network.
The project successfully developed a virtualized demo application that simulates an energy efficiency-enabled network, as proposed in the term paper.
The demonstration shows that exporting flow efficiency information using IPFIX is straightforward and feasible.
The study concludes that while the export and visualization of efficiency data are straightforward, the collection of such data and the implementation of additional data plane functionalities (such as the IOAM protocol) require support from vendors and must be advocated at the IETF.
The research demonstrates that significant information can be extracted from the network with a manageable processing overhead, paving the way for more sustainable networking practices
Design and Implementation of an OS for Use in the Operating Systems Lecture Track
Get PDFThis paper examines all aspects of
memory management in a custom operating system.
The goal is to create a foundation for an interactive
learning tool to be used in the "Operating Systems 1"
and "Operating Systems 2" lectures at OST. Topics
covered include parsing Multiboot2 information,
implementing frame allocation and page tables, and
using these components to remap the kernel. Based
on this, dynamic memory allocation during kernel
runtime was implemented using different allocation
strategies.
The objective of this work is to develop a
modular and extensible memory management system
encompassing physical and virtual memory
management as well as heap management. This
provides a robust foundation for extending other
kernel components while serving as a learning
platform for hands-on exploration of operating system
concepts.
The developed operating system includes:
- Physical memory allocator: Manages the allocation
and deallocation of physical memory, including a
simplistic version without deallocation functionality.
- Virtual memory management: Implements multilevel
page tables to separate logical and physical address
spaces.
- Heap memory allocator: Enables dynamic memory allocation
within the kernel heap. This foundation can be extended
in the future to include additional kernel functionalities
and to expand the feature set of the existing memory
management system
Systematic Identification of Vulnerabilities in C and C++ Source Code through Fuzzing
Get PDFAbstract
Introduction
--------------
As software becomes more complex security issues in applications grow. This research focuses on the use of high-performance fuzzing techniques and also investigates performance parameters for fuzzing in different contexts. Fuzzing is a method of finding software vulnerabilities by injecting random data into programs to reveal and fix potential security flaws. The goal is to use an advanced fuzzing framework to identify vulnerabilities in real-world open-source C and C++ software, thereby improving its robustness and security.
Approach
--------------
To find a suitable project for fuzzing, the search targeted software that accepts input from users or external sources, focusing on areas most likely to contain vulnerabilities. A variety of open-source C and C++ projects with significant user interaction components were selected. A fuzzing harness was then created to test these critical areas of the software, utilizing various inputs and seed values. Employing white-box fuzzing, full access to the source code allowed for more informed tests, simplifying bug identification and avoiding reverse engineering as in black-box fuzzing. Once the tests were executed, the resulting bugs and hangs were analyzed to understand their causes and potential security implications. Metrics such as the number of bugs found, the types of vulnerabilities, and the duration of tests were collected to assess the effectiveness of the fuzzing process.
Conclusion
--------------
This project used advanced fuzzing techniques to test real-world C and C++ open-source projects. The fuzzing framework successfully reproduced many known security vulnerabilities, proving its effectiveness and reliability. Although no new vulnerabilities were found, the high performance and efficiency of the setup make it suitable for ongoing security testing. The metrics collected - such as the number and types of bugs found and test durations - highlighted areas for improvement. The results demonstrate the robustness of the code in the context of penetration testing and security audits, underscoring the importance of continuous security testing and how fuzzing can enhance software security