Papers Index
A searchable listing of the papers in my Zotero.
- Inductive or deductive? Rethinking the fundamental reasoning abilities of llms Aug 2024
- Speech and language processing: An introduction to natural language processing, computational linguistics, and speech recognition with language models Aug 2024
- Logical foundations of artificial intelligence Aug 2024
- The principles of deep learning theory: An effective theory approach to understanding neural networks Aug 2024
- Why can GPT learn in-context? Language models implicitly perform gradient descent as meta-optimizers Aug 2024
- Structured prompting: Scaling in-context learning to 1,000 examples Aug 2024
- Data exploration through dot-driven development Aug 2024
- Mission: Impossible language models Aug 2024
- How large language models will disrupt data management Jul 2024
- A survey on employing large language models for text-to-SQL tasks Jul 2024
- Mamba: Linear-time sequence modeling with selective state spaces Jul 2024
- The composable data management system manifesto Jul 2024
- C++ design patterns for low-latency applications including high-frequency trading Jul 2024
- AutoGen: Enabling next-gen LLM applications via multi-agent conversation Jun 2024
- A critique of Abelson and Sussman or why calculating is better than scheming Jun 2024
- Samba: Simple hybrid state space models for efficient unlimited context language modeling Jun 2024
- On the measure of intelligence Jun 2024
- Look once to hear: Target speech hearing with noisy examples May 2024
- The matrix: a bayesian learning model for llms May 2024
- Umbra: a disk-based system with in-memory performance. May 2024
- Imagebind: One embedding space to bind them all May 2024
- Towards accurate and efficient document analytics with large language models May 2024
- ChuXin: 1.6B technical report May 2024
- Communicative agents for software development May 2024
- Data on the Outside vs. Data on the Inside: Data kept outside SQL has different characteristics from data kept inside. May 2024
- KAN: Kolmogorov-arnold networks May 2024
- Two decades of recommender systems at Amazon.com Apr 2024
- Phi-3 technical report: A highly capable language model locally on your phone Apr 2024
- Megalodon: Efficient LLM pretraining and inference with unlimited context length Apr 2024
- Cramming: Training a language model on a single GPU in one day Apr 2024
- Understanding deep learning Apr 2024
- SWE-agent: Agent computer interfaces enable software engineering language models Apr 2024
- Ferret-UI: Grounded mobile UI understanding with multimodal LLMs Apr 2024
- Physics of language models: Part 3.3, knowledge capacity scaling laws Apr 2024
- More agents is all you need Apr 2024
- Gecko: Versatile text embeddings distilled from large language models Apr 2024
- Adaptive-RAG: Learning to adapt retrieval-augmented large language models through question complexity Apr 2024
- MAGIS: LLM-Based multi-agent framework for GitHub issue resolution Apr 2024
- Self-play fine-tuning converts weak language models to strong language models Mar 2024
- RewardBench: Evaluating reward models for language modeling Mar 2024
- Self-rewarding language models Mar 2024
- Ray: A distributed framework for emerging AI applications Mar 2024
- RAPTOR: Recursive abstractive processing for tree-organized retrieval Mar 2024
- Self-RAG: Learning to retrieve, generate, and critique through self-reflection Mar 2024
- Retrieval-augmented generation for large language models: A survey Mar 2024
- Long-form factuality in large language models Mar 2024
- Segment anything Mar 2024
- Mora: Enabling generalist video generation via a multi-agent framework Mar 2024
- A novel methodology for developing troubleshooting chatbots applied to ATM technical maintenance support Mar 2024
- Neural machine translation by jointly learning to align and translate Mar 2024
- DSPy: Compiling declarative language model calls into self-improving pipelines Mar 2024
- Graphs, algorithms and applications Dec 2023
- ChatGPT's one-year anniversary: Are open-source large language models catching up? Dec 2023
- Conditional variational autoencoder with adversarial learning for end-to-end text-to-speech Nov 2023
- Exponentially faster language modelling Nov 2023
- Expressive query construction through direct manipulation of nested relational results Nov 2023
- LLaVAR: Enhanced visual instruction tuning for text-rich image understanding Nov 2023
- Mistral 7B Oct 2023
- Understanding random forests: From theory to practice Oct 2023
- End-to-end autonomous driving: Challenges and frontiers Sep 2023
- LoRA: Low-rank adaptation of large language models Sep 2023
- Beyond the Imitation Game: Quantifying and extrapolating the capabilities of language models Sep 2023
- Challenging BIG-Bench tasks and whether chain-of-thought can solve them Sep 2023
- BtrBlocks: Efficient columnar compression for data lakes Sep 2023
- Measuring massive multitask language understanding Sep 2023
- GLUE - A multi-task benchmark and analysis platform for natural language understanding Sep 2023
- Scaling instruction-finetuned language models Sep 2023
- BloombergGPT: A large language model for finance Sep 2023
- LLaMA: Open and efficient foundation language models Sep 2023
- Training compute-optimal large language models Sep 2023
- Textbooks are all you need Sep 2023
- Scaling laws for neural language models Sep 2023
- Language models are few-shot learners Sep 2023
- PyTorch FSDP: Experiences on scaling fully sharded data parallel Sep 2023
- ZeRO: Memory optimizations toward training trillion parameter models Sep 2023
- Evaluating large language models trained on code Aug 2023
- SeamlessM4T-Massively multilingual & multimodal machine translation Aug 2023
- Smart Guy Productivity Pitfalls Jul 2023
- How not to buy happiness Jul 2023
- Knowledge Workers are Bad at Working (and Here's What to Do About It...) Jul 2023
- Five things we need to know about technological change Jul 2023
- Robert De Niro's Method: acting, authorship and agency in the New Hollywood (1967-1980) Jul 2023
- Ologs: a categorical framework for knowledge representation Jul 2023
- Tail Protection for Long Investors: Trend Convexity at Work Jul 2023
- Large language models can be easily distracted by irrelevant context Jul 2023
- Distributed transactions at scale in amazon {DynamoDB} Jul 2023
- Linear types can change the world! Jul 2023
- What should data science education do with large language models? Jul 2023
- Nominal logic programming Jul 2023
- Chase, chance, and creativity: The lucky art of novelty Jul 2023
- Technical Perspective: FoundationDB Performs Balancing Act Jul 2023
- Temporal Interaction Contracts for Components in a Distributed System Jul 2023
- Device Configuration in 4.4BSD Jul 2023
- Probably Approximately Correct: Nature's Algorithms for Learning and Prospering in a Complex World Jul 2023
- Requirements engineering in the year 00: A research perspective Jul 2023
- Concepts, techniques, and models of computer programming Jul 2023
- Teaching programming broadly and deeply: the kernel language approach Jul 2023
- Memory Resource Management in VMware ESX Server Jul 2023
- Capacity and Performance Overhead in Dynamic Resource Allocation to Virtual Containers Jul 2023
- Generic User-Level PCI Drivers Jul 2023
- The computer for the 21st century Jul 2023
- Factored Operating Systems (fos): The Case for a Scalable Operating System for Multicores Jul 2023
- The Grammar of Graphics (Statistics and Computing) Jul 2023
- JFFS: The Journalling Flash File System Jul 2023
- TCP/IP Illustrated, Volume 2 Jul 2023
- Automatically Generating Malicious Disks using Symbolic Execution Jul 2023
- Fs-utils: File Systems Access Tools for Userland Jul 2023
- A Feather-weight Virtual Machine for Windows Applications Jul 2023
- Where do operations come from? A multiparadigm specification technique Jul 2023
- Implementing a Clonable Network Stack in the FreeBSD Kernel Jul 2023
- DDE/DDEKit Jul 2023
- E2fsprogs: Ext2/3/4 Filesystem Utilities Jul 2023
- fuse-ext2 Jul 2023
- libguestfs: tools for accessing and modifying virtual machine disk images Jul 2023
- pkgsrc: The NetBSD Packages Collection Jul 2023
- Slirp, the PPP/SLIP-on-terminal emulator Jul 2023
- thttpd – tiny/turbo/throttling HTTP server Jul 2023
- ZFS Source Tour Jul 2023
- carp – Common Address Redundancy Protocol Jul 2023
- WAPBL – Write Ahead Physical Block Logging file system journaling Jul 2023
- pud – Pass-to-Userspace Device Jul 2023
- ndis – NDIS miniport driver wrapper Jul 2023
- LittleTable: A Time-Series Database and Its Uses Jul 2023
- Blinding Us to the Obvious? The Effect of Statistical Training on the Evaluation of Evidence Jul 2023
- A Comparison of Approaches to Large-scale Data Analysis Jul 2023
- What can the programming language Rust do for astrophysics? Jul 2023
- Scaling Transformer to 1M tokens and beyond with RMT Jul 2023
- Above the clouds: A Berkeley view of cloud computing Jul 2023
- Human variation in overriding attentional capture Jul 2023
- A Compositional Trust Model for Predicting the Trust Value of Software System QoS Properties Jul 2023
- Fast and Flexible Application-level Networking on Exokernel Systems Jul 2023
- View-OS: A New Unifying Approach Against the Global View Assumption Jul 2023
- When Virtual is Harder than Real: Security Challenges in Virtual Machine Based Computing Environments Jul 2023
- Induction and Deduction in Bayesian Data Analysis Jul 2023
- Shared Libraries in SunOS Jul 2023
- NetBSD-current/i386 build status Jul 2023
- Seven myths of formal methods Jul 2023
- An ontology-enhanced cloud service discovery system Jul 2023
- Simply Scheme: introducing computer science Jul 2023
- The Mungi Single-Address-Space Operating System Jul 2023
- Unix under Mach: The Lites Server Jul 2023
- Passive Serialization in a Multitasking Environment Jul 2023
- MINIX 3: a highly reliable, self-repairing operating system. Jul 2023
- Large-scale Virtualization in the Emulab Network Testbed Jul 2023
- An Architectural Overview of QNX Jul 2023
- Fault Injection Techniques and Tools Jul 2023
- Why Functional Programming Matters Jul 2023
- Singularity: rethinking the software stack Jul 2023
- SODA: A Service-On-Demand Architecture for Application Service Hosting Utility Platforms Jul 2023
- Two's company, three is complexity : a simple guide to the science of all sciences Jul 2023
- Application Performance and Flexibility on Exokernel Systems Jul 2023
- Jails: Confining the omnipotent root Jul 2023
- Rump Device Drivers: Shine On You Kernel Diamond Jul 2023
- Environmental Independence: BSD Kernel TCP/IP in Userspace Jul 2023
- Rump File Systems: Kernel Code Reborn Jul 2023
- puffs - Pass-to-Userspace Framework File System Jul 2023
- Flexible operating system internals: the design and implementation of the anykernel and rump kernels Jul 2023
- Code Testing and Its Role in Teaching Jul 2023
- Vnodes: An Architecture for Multiple File System Types in Sun UNIX Jul 2023
- Programming languages: Application and interpretation Jul 2023
- Time, clocks, and the ordering of events in a distributed system Jul 2023
- Hints for Computer System Design Jul 2023
- Debugging kernel problems Jul 2023
- Wombat: A Portable User-Mode Linux for Embedded Systems Jul 2023
- Unmodified Device Driver Reuse and Improved System Dependability Via Virtual Machines Jul 2023
- On μ-Kernel Construction Jul 2023
- Improving IPC by Kernel Design Jul 2023
- Jitsu: Just-in-time Summoning of Unikernels Jul 2023
- Unikernels: Library Operating Systems for the Cloud Jul 2023
- Unikernels: Library Operating Systems for the Cloud Jul 2023
- An intuitionistic theory of types Jul 2023
- ClickOS and the Art of Network Function Virtualization Jul 2023
- System V Application Binary Interface, AMD64 Architecture Processor Supplement, Draft Version 0.99.5 Jul 2023
- Solaris Internals: Core Kernel Architecture Jul 2023
- The BSD packet filter: a new architecture for user-level packet capture Jul 2023
- Exploiting Deferred Destruction: An Analysis of Read-Copy-Update Techniques in Operating System Kernels Jul 2023
- The Design and Implementation of the 4.4BSD Operating System Jul 2023
- Soft Updates: A Technique for Eliminating Most Synchronous Writes in the Fast Filesystem Jul 2023
- A Fast File System for UNIX Jul 2023
- Design of a General Purpose Memory Allocator for the 4.3BSD UNIX Kernel Jul 2023
- Journaled Soft-updates Jul 2023
- Automated Testing Framework Jul 2023
- Private communication Jul 2023
- build.sh: Cross-building NetBSD Jul 2023
- Response time in man-computer conversational transactions Jul 2023
- Kerberos Authentication and Authorization System Jul 2023
- The Mether System: Distributed Shared Memory for SunOS 4.0 Jul 2023
- Amoeba: A Distributed Operating System for the 1990s Jul 2023
- Model Checking Large Network Protocol Implementations Jul 2023
- Mutt Email Client Jul 2023
- A Comparative Study of Programming Languages in Rosetta Code Jul 2023
- NetBSD Project Jul 2023
- Valgrind: A Framework for Heavyweight Dynamic Binary Instrumentation Jul 2023
- Mtools Jul 2023
- Programming in Martin-Löf's type theory Jul 2023
- Purely Functional Data Structures Jul 2023
- OpenSSH Jul 2023
- The Distribution of Faults in a Large Industrial Software System Jul 2023
- Active database systems Jul 2023
- Systems Software Research is Irrelevant Jul 2023
- Plan 9 from Bell Labs Jul 2023
- Strong Inference Jul 2023
- How to Believe a Machine-Checked Proof Jul 2023
- Rethinking the Library OS from the Top Down Jul 2023
- IRON File Systems Jul 2023
- MDE-URDS-A Mobile Device Enabled Service Discovery System Jul 2023
- Daytona : A User-Level TCP Stack Jul 2023
- The Transport Layer Security(TLS) Protocol Jul 2023
- LKL: The Linux Kernel Library Jul 2023
- Machine-Independent Virtual Memory Management for Paged Uniprocessor and Multiprocessor Architectures Jul 2023
- netmap: A Novel Framework for Fast Packet I/O Jul 2023
- An Implementation of a Log-Structured File System for UNIX Jul 2023
- The bootstrap Jul 2023
- UBC: An Efficient Unified I/O and Memory Caching Subsystem for NetBSD Jul 2023
- A. NONSTANDARD FOR TRANSMISSION OF IP DATAGRAMS OVER SERIAL LINES: Jul 2023
- VINO: An Integrated Platform for Operating System and Database Research Jul 2023
- File System Aging—Increasing the Relevance of File System Benchmarks Jul 2023
- Container-based Operating System Virtualization: A Scalable, High-performance Alternative to Hypervisors Jul 2023
- The art of Prolog: advanced programming techniques Jul 2023
- Using Declarative Invariants for Protecting File-System Integrity Jul 2023
- FUSE: Filesystem in Userspace Jul 2023
- A Machine-Independent DMA Framework for NetBSD Jul 2023
- Expressions on the nature and significance of programming and play Jul 2023
- TinyStories: How Small Can Language Models Be and Still Speak Coherent English? Jul 2023
- Sparks of Artificial General Intelligence: Early experiments with GPT-4 Jul 2023
- An aperiodic monotile Jul 2023
- Structure and Interpretation of Computer Programs Jul 2023
- Mach: A New Kernel Foundation for UNIX Development Jul 2023
- The Dataflow Model: A Practical Approach to Balancing Correctness, Latency, and Cost in Massive-scale, Unbounded, Out-of-order Data Processing Jul 2023
- Scheduler Activations: Effective Kernel Support for the User-level Management of Parallelism Jul 2023
- Resource containers: a new facility for resource management in server systems Jul 2023
- Xen and the Art of Virtualization Jul 2023
- The Multikernel: A new OS architecture for scalable multicore systems Jul 2023
- QEMU, a Fast and Portable Dynamic Translator Jul 2023
- Lightweight Remote Procedure Call Jul 2023
- SPIN - an extensible microkernel for application-specific operating system services Jul 2023
- Making Components Contract Aware Jul 2023
- Contract Aware Components, 10 years after Jul 2023
- Quantitative evaluation of software quality Jul 2023
- Threads Cannot Be Implemented as a Library Jul 2023
- ZFS: The Last Word in Filesystems Jul 2023
- The Slab Allocator: An Object-Caching Kernel Memory Allocator Jul 2023
- A formal approach to component adaptation Jul 2023
- No Silver Bullet: Essence and Accidents of Software Engineering Jul 2023
- Relational programming in minikanren: techniques, applications, and implementations Jul 2023
- Type systems Jul 2023
- Sense and respond systems Jul 2023
- Caltech infospheres project overview: Information infrastructures for task forces Jul 2023
- Distributed snapshots: determining global states of distributed systems Jul 2023
- Sharing and Protection in a Single-Address-Space Operating System Jul 2023
- Nominal Logic Programming Jul 2023
- An Empirical Study of Operating Systems Errors Jul 2023
- Power-law distributions in empirical data Jul 2023
- Logic programming and constraint logic programming Jul 2023
- Redesigning the BSD Callout and Timer Facilities Jul 2023
- Design and Implementation of the UVM Virtual Memory System Jul 2023
- An Architecture for a Secure Service Discovery Service Jul 2023
- A model-based analysis of first-generation service discovery systems Jul 2023
- Porting the ZFS file system to the FreeBSD operating system Jul 2023
- Modeling Creativity Jul 2023
- MapReduce: simplified data processing on large clusters Jul 2023
- Linking Programs in a Single Address Space Jul 2023
- NAOMI–an experimental platform for multi–modeling Jul 2023
- Low-Impact Operating System Tracing Jul 2023
- User-Level Implementations of Read-Copy Update Jul 2023
- A user-mode port of the Linux kernel Jul 2023
- The Minet TCP/IP Stack Jul 2023
- The CryptoGraphic Disk Driver Jul 2023
- Think Complexity: Complexity Science and Computational Modeling Jul 2023
- Unifying the User and Kernel Environments Jul 2023
- What Every Programmer Should Know About Memory Jul 2023
- Making Data Structures Persistent Jul 2023
- Design and Implementation of the lwIP TCP/IP Stack Jul 2023
- The Matter of Heartbleed Jul 2023
- Three Implementation Models for Scheme Jul 2023
- A Peek at the DragonFly Virtual Kernel Jul 2023
- A 250-year argument: Belief, behavior, and the bootstrap Jul 2023
- Bootstrap methods: another look at the jackknife Jul 2023
- Alpine: A User-Level Infrastructure for Network Protocol Development Jul 2023
- Exokernel: An Operating System Architecture for Application-Level Resource Management Jul 2023
- How to design programs: an introduction to programming and computing Jul 2023
- The Flux OSKit: A Substrate for OS and Language Research Jul 2023
- Vx32: Lightweight User-level Sandboxing on the x86 Jul 2023
- The physiology of the grid Jul 2023
- The anatomy of the grid: Enabling scalable virtual organizations Jul 2023
- Thinking Like Transformers Jul 2023
- Naiad: a timely dataflow system Jul 2023
- Attention is All you Need Jul 2023