00:00:28.960
Hello there, I'm Yukihiro "Matz" Matsumoto, the creator of the Ruby language. I apologize for not being able to attend RubyConf Taiwan physically this year. I was planning to be there but, at the end of last month, I discovered an issue with my right eye's retina that required an operation. Don’t worry too much; the operation went well, and I am recovering.
00:00:36.040
However, to avoid any risks, I decided to cancel my trip to Taiwan. I'm truly sorry about that, but I'm glad you are here attending the conference. It's heartwarming to see so many people showing interest and love for my programming language.
00:00:43.960
This year, I'm going to talk about the 30 years of Ruby. In fact, 2023 marks the 30th anniversary of Ruby’s development; I started developing it back in 1993, exactly 30 years ago. It began as a hobby project. I started programming when I was 15, using the BASIC programming language on a very limited computer. The computer had a tiny subset of BASIC language, and I found it frustrating due to its limitations, such as only having global variables, no recursion, and no function names, just GOTO statements and arguments passed only through global variables.
00:02:05.200
That programming environment felt very limiting, and since I didn't know any other languages, I thought programming was a complicated and frustrating endeavor. One day, I discovered a book on the programming language Pascal in a local bookstore. I bought it and read through it, which opened my eyes to the existence of many programming languages. I realized that the frustration I felt could be addressed by better programming language design. This awakening sparked my love for programming languages, leading me to study many of them.
00:02:57.600
Ruby, my language, is a product of this passion for programming languages. You could call me a language geek; I appreciate many programming languages and enjoy learning about their trivia. Let me share some lessons we can learn from the history of programming languages. For example, one question that often comes up is: What is the first programming language in the world? In many discussions, FORTRAN, developed around 1954, is often considered the first programming language.
00:04:04.640
However, before FORTRAN, there was a language named Plankalkül, devised by the German engineer Konrad Zuse for his computer, the Z3. Zuse's work was groundbreaking as he sought to develop a more abstract way to communicate human ideas to computers, beyond mere machine language. His papers included concepts like assignments, conditional statements, loops, arrays, and exceptions, which were visionary, particularly in the early 1940s.
00:05:19.200
Unfortunately, Plankalkül was lost to history, mostly due to the turmoil caused by World War II, which hindered Zuse's development of his ideas. He later reassembled his thoughts and published a specification for Plankalkül in 1972. However, implementing it was a challenge, as its concepts were so advanced that no implementation was available until 1998, well after the development of Ruby.
00:06:41.039
This teaches us that having an idea is important, but having a working implementation and fostering evolution is far more critical. We must provide usable implementations and develop alongside our users. This is the first lesson from the history of Plankalkül.
00:07:28.240
The second lesson relates to simplicity in programming languages. I can name a few languages known for their simplicity, such as Lisp, Forth, and APL, all born in the 1960s. Unfortunately, none of them gained long-term popularity, which can be explained by a quote from Larry Wall, the creator of Perl: "If a language is simple, our software will become more complex because the total amount of complexity is constant." This insight reflects the idea that while a simple language may seem beneficial, it often leads to more complex software in practice.
00:08:43.440
In fact, Ruby is not the simplest language; although it appears straightforward, it is quite complex internally. Ruby aims to simplify application development for humans, as human thoughts are complex. Thus, to adequately reflect our mental models, a programming language like Ruby needs to incorporate some level of complexity. In this sense, we can learn from Perl and other languages about the balance between simplicity and practicality.
00:09:51.159
Within the community, there’s a common discussion about programming languages that have become too complex due to their features. Some languages aim to provide every imaginable feature, resulting in what I call "creeping featurism." If we continue to add every feature, applications can grow too large and cumbersome to manage effectively. Therefore, it’s crucial to maintain some level of simplicity in both programming languages and applications.
00:11:03.120
Pearl, for instance, gives us lessons regarding maintaining language simplicity amid feature expansion. The name Ruby was indeed inspired by Perl, and I learned a lot from it. As time passed, Perl faced challenges where its core developers felt weighed down by historical burdens, leading them to claim they were bored with stagnation.
00:12:14.520
Recognizing this boredom, the Perl community began to launch new projects to redefine their language, resulting in many proposals to revive interest. They compiled a set of design guidelines known as the "apocalypses" in an effort to reimagine Perl as Perl 6. Unfortunately, despite the evolution and potential of Perl 6 (now known as Raku), it did not achieve the desired popularity, which serves as another cautionary tale about the importance of keeping a programming community engaged and excited.
00:13:30.600
Boredom is a significant enemy of any open-source project. We must keep moving forward to maintain interest. Continually improving our tools and language is critical to avoiding stagnation. Thus, Ruby's development has been about incremental improvements rather than drastic, sweeping changes that lead to historical burdens.
00:14:41.000
As I mentioned before, I attempted to follow Perl’s example at RubyConf 2003 by introducing Ruby 2. My aim was to create a language without historical burdens. However, I learned many lessons from this endeavor. I initially collected exciting RFC proposals but eventually abandoned the ideas due to the fatigue of managing so many changes. Instead, I focused on gradually improving Ruby without discarding the past.
00:15:23.200
This gradual approach was what led to Ruby 1.n, an iterative improvement of Ruby 1.8. It allowed us to focus on enhancing the core of the language, introducing better features without creating excessive complexity or confusion for users. We faced some incompatibility, especially regarding string encoding, but our careful and gradual approach yielded better overall results.
00:16:32.960
Reflecting on the languages in the community, we can see how various factors, such as performance and upgrade paths, influence user retention and involvement. As developers, we want to ensure that the improvements we make reflect the needs and realities of modern programming while also remaining true to Ruby's original philosophy.
00:17:50.560
The discussion surrounding static typing continues to emerge, as seen with languages like Rust, Go, and TypeScript. Ruby intentionally avoids static typing, valuing dynamic typing as a part of its identity. However, we are exploring ways to implement optional static-type features. This would be beneficial in instances without compromising Ruby's essence.
00:19:03.120
Even so, approaches must be carefully measured to ensure that they don't introduce unnecessary complexity or reduce Ruby's accessibility for new developers. Community input is vital to maintaining Ruby's forward momentum and identifying areas for potential improvement.
00:20:25.680
While we can't predict the future exactly, our continuous efforts to evaluate and adapt Ruby will shape its path. We aim for a sustainable Ruby that not only endures for the next 30 years but continues to create impactful value for users in the community. Aiming for Ruby 40 may sound ambitious, but I believe that with the right strategy and focus on grassroots development, it could be a reality.
00:21:43.440
As we move forward, I encourage all of you to actively participate in the Ruby community. Together, we can ensure that Ruby remains relevant, accessible, and valuable to developers worldwide. Your ideas and contributions matter. Let's create the future of Ruby together.
00:22:57.960
Thank you all once again for being a part of this conference and contributing to the Ruby community. I truly appreciate your presence here.
00:23:34.080
Now, let's move into a Q&A session. If you have any questions, please feel free to raise your hand, and I will pass the microphone to you. I apologize for not being there to engage directly, but I truly value this interaction and look forward to your questions.