Are you feeling the weight of uncertainty in the programming world as the D Language grapples with challenges amidst the rise of competing languages? There's a looming concern that these hurdles might hold D back from its true potential, relegating it to a lower standing. The cost of letting this happen is significant, not just for D enthusiasts but for the entire programming community. Yet, a solution exists; a way to steer D towards the path of popularity and influence it deserves. There is an unexpected approach to unlocking the value behind the language, and the result will shape D's future and elevate your own personal and professional success. Don't miss out on this discourse that promises to transform your perspective on what DLF means to all of us.

Like many modern programming languages, D has a static type system and built-in tuple support. In this talk, I will present general design considerations around type systems, with a particular focus on D’s type system, recent developments in D, and possible avenues for further improving the soundness, expressiveness, and ergonomics of D. As some operations on tuples remain rather clunky in today’s D, this will in particular include design considerations around tuples and a number of different proposals for how to move forward.

The absence of a proper compiler library has been haunting the D ecosystem since forever. Although progress has been made in creating a public API, there is a lot of room for improvement. In this talk, I will discuss the major challenges of developing a proper compiler interface for DMD-as-a-library, what has been done so far, what are the future plans, and what will be the limitations.

Should D have a smarter Garbage Collector, or support Reference Counting? I don’t care. Stack memory is where it’s at! D is really good at it with its static arrays, slices, and DIP1000’s lifetime tracking to make it all memory-safe. DIP1000 has evolved a lot in its design and implementation, so I’ll get you up to speed with where we are now and how we got here.

DIP1000 adds quite a bit of syntax to the language and makes D look a lot less beautiful, in my opinion. Instead of trying to add things to the language, why not take a look at things that need to be removed to achieve the same level of memory safety? This talk shows how to remove three things from the language to make it memory-safe and still live with the consequences.

C is the lingua franca of programming languages. Chances are, if something exists in the world of computer science, there is a version of it in C. But what if you use D? The great news is that any C project is almost trivially accessible via D. But what if you hate the problems that come with C? No overloading! No operators! Zero-terminated strings! Manual memory management! No memory safety! Many of these things led me to undertake a project of porting a quite broad and well-used C library to D. What might be in store for you if you decide to take this journey? Tune in to find out!

When building software services using D, a practical reality is that most other services are not also using D. A fairly standard way of inter-service communication is accomplished via a REST Architecture, based on JSON over HTTPS, for example. However, writing a new client for every programming language is error-prone and labor intensive. The internals of the OpenAPI Client library are discussed showing how D Client code can be generated using mixins and templates from OpenAPI specifications, permitting compatibility with well known APIs such as Slack, Stripe, or OpenAI.

Have you ever looked at code you wrote five years ago and wondered what you were thinking? Just think of code you authored even further back! You’ve heard about secure code, safe code, clean code, modern code, optimized code, clever code, user-friendly code, structured code, effective code, etc. Everybody thinks they write easy-to-understand code (including me), but your future self will likely have the last word on that.

Here I’ll be talking about writing easy-to-understand code. The talk is based on decades of experience writing code that is hard to understand. I’ll show how D makes it easy to write easy-to-understand code. It won’t cost anything, either. And who knows? Maybe your future self will sigh contentedly with “I wrote that!”

The highest praise you can get for your code is someone else looking at it saying “that’s so simple, anyone could have done it!” (But you and I know better!)

In this talk, I will discuss how a three-year ongoing game engine project in D has been able to run on multiple platforms while staying consistent, fast, and easy to use.

In January of 2023, I excitedly showed a group of over 110 university students that D is the 48th most popular programming language on the Tiobe Index (for whatever its metrics are)—and then told those students they would be learning D in the software engineering course that semester. In this talk, I will recap my university curriculum of how I taught D, and why I think D should be taught by more faculty in universities. For this software engineering course, we made use of low-level access, multiple programming paradigms, built-in profilers, package management (dub), code coverage, ddoc, and unit testing in order to build a half-semester long project. My conclusion is that using D at university can give students a competitive advantage versus other languages, and in this talk I’ll reflect on the curriculum, pain points, strengths, and future of D in education.

In January of 2023, around 110 students took Foundations of Software Engineering with Professor Mike Shah at Northeastern University. During the first class, it was announced that the course would be taught in D. This talk will follow the perspective of four students (one group) in said course, beginning with their experience learning the D programming language.

The main portion will discuss the creation and implementation of the half-semester long final project: an interactive networked whiteboard application with a couple of features (chat, brushes). Various tools and add-ons this project used were GtkD, networking, package management (dub), code coverage, and unit testing (unit-threaded). To conclude, this talk will discuss the main benefits of D as a post-secondary educational language and reflect on the state of the D community and development tools.

NOTE: This talk immediately follows, and is a continuation of, Mike Shah’s talk, with no break in between.

Different hardware architectures implement different memory models. This in turn makes porting multi-threaded software between different target architectures an insanely complicated task. To solve this problem, C++11 introduced a language memory model that was later adopted by other languages such as D and Rust.

In this talk, we’ll present the C++11 memory model, including multiple options for atomic accesses that lie on the trade-off between performance and the consistency level they support. Due to the well known complexities and pitfalls in this kind of programming, we will also consider several safe patterns to work with atomic variables that lower the chances of introducing bugs.

Serpent OS is a Linux distribution heavily utilizing D for its tooling, infrastructure, and software update processes. It’s been an extensive journey, with lots of mistakes made along the way. Learn how we screwed up - so you don’t have to!

Multiplix is an operating system written in D under development for a research project at Stanford University. Kernel code is an unusual setting where there is no surrounding infrastructure, thus requiring hand-written assembly, a specialized build process, and custom implementations for core features like memory allocation and concurrency primitives. This talk will explain how we are using D for OS development, and show examples of how to write bare-metal D code. The talk will go over the architecture of Multiplix with an emphasis on how the D language has shaped it. I’ll also discuss our experiences using D for kernel development, and the benefits and challenges that arise from using D in this setting.

Want to see what D would look like with native sumtypes, rich types, better lambdas, and macros?

An old man yells his pet peeves at the clouds.

The first part of this talk demonstrates the process of internationalizing an existing program (adding support for multiple natural languages to its user interface) using the dub gettext package. The second part focuses on the implementation of said package, which makes interesting use of various features of the D programming language.

QUIC is a new, standardized and widely adopted internet protocol. A native library within the D ecosystem would pave the way towards HTTP/3 adoption. Furthermore, it would remove the reliance on bindings to third party C implementations and would facilitate the use of features like D exceptions and fiber-based concurrency.

This talk aims to present my progress on bringing QUIC to the D environment. I will talk about why someone might consider using QUIC over other protocols. I will present the challenges that I encountered and how the solutions reflect into the design of quic-d. I think that the requirements of QUIC framing/packetization and streams made an interesting case of using D’s features, like introspection. I will conclude by presenting some possible improvements and opportunities.

Got something interesting to tell the D community, but not interested in presenting a full talk? We’ll give you five minutes to tell the world!

Lightning Talks are presentations restricted to five minutes or less. Speakers plug in their laptops and get started immediately. When their time is up, the emcee pulls them off stage and the next speaker gets going. The Lightning Talk session from DConf ‘22 is a great example of the format.

Any DConf attendee can sign up to present a Lightning Talk. We’ll have nine slots available this year, and we’ll fill them on a first-come first-serve basis. Email social@dlang.org anytime before the conference to reserve your spot (after you’ve registered), or let Mike Parker know at any point during the conference prior to the start of the Lightning Talks session.

I will talk about my journey learning AI, what I’ve discovered about it, the ins and outs most people do not understand, and how I did it all purely in D. I was able to implement neural networks to do a variety of tasks, such as text and color recognition. I’ve created my own neural network creator software, which in turn was also written in D.

Even in their infancy, large language models like ChatGPT are the talk of the town. Until recently, LLMs have been inferenced (run) using huge chunks of Python code, but recent interest has brought about some much simpler, specialized, libraries written in native languages (llama.cpp being a recently famous example). In this talk, Max talks about the state of LLMs and how they might be useful for D programmers.

This year, it isn't only Walter and Átila in the hotseat! They'll be joined on stage by Mathias Lang, one of the DLF team members in charge of our high-level goal to enhance the D ecosystem; Dennis Korpel, one of our Pull Request and Issue Managers; Mike Parker, one of the DLF team members in charge of our high-level goal to strengthen the D community; and Saeed Sabeti, who's joining to take questions about Ucora's organizational redevelopment program.

Curious about the DLF’s organizational redevelopment? Wondering what’s in store for the language, ecosystem, and community down the road? Eager to learn more details about progress on our current goals? Dying to hear any juicy bits of history from Walter’s decades as a C compiler developer? All of these topics and more are on topic for the annual DConf Ask Us Anything!