Compile | nuclear Coke
Editor| Yanshan
"I used to know nothing about technology, but now I've mastered programming and started trying to gain autonomy in computing. While there is still a long way to go, I have at least taken a step forward. ”
Recently, the Free Software Foundation (FSF) announced the winners of the 2021 Free Software Awards. Presented at the LibrePlanet 2022 conference, the series of awards is given to individuals, teams, and communities who have made significant contributions to the cause of software freedom. Encouragingly, Protesilaos Stavrou ("Prot"), a non-technical background, received the Award for Outstanding New Free Software Contributor this year, which is awarded to new members of the community who have made outstanding contributions to the free software community.
In its acceptance speech to Prot, the FSF wrote that since 2019, the philosopher has been a mainstay of the GNU Emacs community through his blog posts, conference talks, live videos, and code contributions.
Yes, you read that right, today's protagonist Prot is a liberal arts student who is passionate about philosophy, born in 1998, with a non-technical background, a university study of humanities, and has only begun to touch technology in recent years. Therefore, he was very surprised by his award.
Zo Kooyman, Executive Director of FSF, said: "Protesilaos is a very inspiring role model for those who are just starting out in their community. This shows that one does not need to have decades of experience to contribute to free software or even become central to a particular project. ”
Many netizens also expressed their congratulations and respect for Prot:
Prot is one of the most eloquent, humble, discreet and healthy people I've ever met. It's crazy to think that he approached Emacs and Lisp without any technical background and was just starting to contribute. Cheers to you, Prot! ——gitrog
The speed at which he picked it up (Emacs and Lisp) with almost no background was staggering. I learned Linux/UNIX in 2016 and only started using Emacs in 2019. Another interesting fact: he did those tutorial videos mainly to practice his English. ——BeetleB
GNU EMACS is an extensible, customizable, free, free text editor. It is also an integrated development environment. Over the past two and a half years, he's written thousands of lines of Elisp and contributed to the core Emacs, including two complete, fully accessible, customizable themes, modus-themes, according to Prot's self-report.
"When I came to Emacs, when I switched to Emacs, when I joined the environment two and a half years ago, I found everything I needed. With high-quality documentation, great programs for GNU Emacs, tons of blogs and tutorials, and of course interactions with different people, you'll always learn something new. "While this award is given to individuals, I think it's really about the community — all the unsung heroes in the community who help a particular person achieve certain goals." ”
"No one would have achieved anything meaningful without the unsung heroes in our lives." Prot says.
The following is an excerpt from Prot's talk at LibrePlanet 2022, where he shares why he chose Emacs and his experience and understanding of free software in hopes of inspiring readers.
Become an iron fan of Emacs
Here I want to talk about why I became an iron fan of Emacs. The advanced features and rich packages are certainly good, but that's not enough to capture the essence of Emacs, especially its true value proposition. After all, most modern editors today have plug-in systems that provide users with almost all the necessary temporary functions, so what is special about Emacs?
The answer is that Emacs is not really a text editor. It is actually a programmable platform, and text editing is just one of the main interaction points.
Emacs is a dialect of Lisp called "Emacs Lisp", also known as "Elisp". As a result, most of its code base and user configurations are also written in Elisp. This means that for end users, Emacs involves only one language and contains only one paradigm. As a result, there is no difference between the built-in code and the user-developed plug-in code, which truly achieves a great unity of language style.
At the heart of Emacs is the ability to read and run Elisp, which is known as evaluation evaluation. When evaluating Elisp, the Emacs environment can easily use the corresponding return value. Without restarting the program, these extensions take effect in real time, helping users to interactively see the effects instantly.
From this perspective, Emacs is the equivalent of a Lisp machine that can be used to execute any type of program. "Program" here refers to everything, from big features like Org or Magit to small applications like streamlined text editing and manipulation.
In addition, Emacs is self-documenting, meaning that it understands when the value of a variable changes and notifies the user in the corresponding help buffer. Similarly, Emacs reflects the correlation of new values for various functions with the current state.
Finally, Emacs is purely free software that provides directly with built-in tools and the complete source code for all installed packages. In this way, the display content in the document is integrated with the execution content of the actual program, without any barriers.
I think of Emacs as an integrated computing environment
I started using Emacs in the summer of 2019, and I didn't know anything about Lisp before, and my programming level wasn't high. When I was in college, I studied the humanities, and all the hardcore techniques were gradually mastered in recent years.
The Emacs appealed to me because the Lisp machines showed great potential. What I wanted was an integrated development layer that was different from the usual daily computing tools, and I wanted to have a unified theme, precise typography, and a common operation/interaction pattern. In addition, I want to be able to establish a connection between different contexts or interfaces: my mail client should be able to talk directly to task schedulers and file managers, the configuration I use when writing text also needs to be directly applicable to the programming interface, and so on.
Emacs fully met all my needs with its own and third-party packages/custom code. If you're willing to learn a little bit about Elisp, Emacs has endless possibilities. Let's take a look at a few common workflows that don't require much skill:
Use the completion framework to search the contents of a file asynchronously, placing the results in a dedicated buffer and editing in place. Finally, propagate the changes to all relevant documents.
Capture the current email content and generate to-do items based on it. Tasks can also contain a link that returns the original message and can display the corresponding scheduled date and due date in the agenda.
Flag certain files in Dired and add them to the email you're composing. Dired can tag entries individually, or you can use regular expressions and other advanced commands.
Record a set of actions ("keyboard macros") that start with Dired, jump to a specific file, make certain changes, return to the file manager, and repeat the process in the next file.
In the various use cases above, users do not need to learn anything new at all. For example, various functions such as keyboard macros can be used directly wherever they are. What's more, these features work alone or work together.
As a result, Emacs is able to connect the various interfaces without any conflict caused by context switching.
The final advantage of Emacs is ease of use and ease of use at scale. For example, I want to make a demo in this talk with custom code. Because the screen occupies only a small part of the document, many friends will think that this is a pre-built PPT. No, I can edit the normal text inside directly. So I'm actually using the minimalist "focus mode" of Emacs, which works well in presentation, reading, writing, and programming scenarios.
And everything I do in Emacs only needs to be implemented once. I don't need to set up a custom focus mode in the email client, or set up more other focus modes for the text editor/processor or agenda planner. Not at all, just use the same pattern. Plus, I don't need a separate tool for text writing and rendering, all functions are unified and interoperable, so good and simple!
In addition, the underlying configuration is also all done in Elisp, which further simplifies the overall effect. Before using Emacs, I tended to have to use a different paradigm and/or language for each application. For example, Thurderbird and Libreoffice have different settings menus and are not interoperable with each other. Mutt has its own way of configuring, Vim and Tmux are also, and the terminal simulator is still, forcing people to do useless work over and over again.
I'm not saying that applications shouldn't be configured in their own way. I'm just suggesting that they should be used in combination, and the current state of being unrelated and fragmented from each other is certainly not good enough. Users can only do their best to piece together the overall system with a single island of functions. And even with great effort, there may still be deficiencies or even security flaws, as these programs do not come from the same platform or use the same language.
In Emacs, each new feature pack automatically gets what's already in the other packages, such as the same font configuration and theme, common operation and interaction patterns, and so on. With this foundation, we can greatly accelerate the progress of the workflow. Everything that happens inside Emacs exists in the same environment, all contexts can be related to each other, and users can make this association at will. This highly integrated and unique unified experience also forms the core of Emacs' value proposition.
Consistency and autonomy
Emacs is free software in terms of licensing. But the freedom it brings to end users is by no means limited to the legal or ethical level, but more at the practical level – that is, the integrated computing environment mentioned earlier.
The scalability of Emacs enables users to truly perform an extremely wide range of processing tasks with their own computing devices. At the same time, the unified nature of Elisp lowers the barrier to entry, eliminating the need to piece together applications without a common foundation.
Freedom in everyday life is precious, and Emacs is a tool that represents the desire for freedom and helps us to get as close as possible between our development goals and the results that our computers present.
The freedom of software is embodied in the ownership of computing means. Based on flexible ownership, we can develop autonomously in the computing space. This autonomy allows us to choose tools for our stated goals at will, free from the constraints of hard-coded, or even fixed, physical services.
In my opinion, the lack of integration between the various applications that I use on a daily basis is definitely a big problem to watch. I don't feel like I'm getting the rights I deserve, and I can't get the tools to do what they want. So the biggest contradiction arises: free software limits my autonomy and makes me unfree. This creates 1+1
In other words, these tools are "teaching us to do things," and we as users have no influence on the formulation of these "dogmas."
But with the help of Emacs, I was able to eliminate these heterogeneous and heterogeneous elements in my daily calculations. Now, almost everything I do on Emacs: read and write, file management, task planning and organization, email exchanges, music collection and playback, Internet browsing, and more. The only exception is that I really can't live without a graphical web browser.
Let's talk a little more about the abstract. The concept of freedom has two dimensions: nominal freedom and substantive freedom. The former is reflected in the licensing that the codebase follows, while the latter is reflected in the content of the codebase itself—that is, the overall user feel, and how the codebase matches other programs or workflows in a particular environment. I find the topic of software freedom particularly interesting and worth exploring. Correctness, composability, and scalability are all basic attributes of software code, and only by organically combining these attributes can the program be fully functional in practice. So what we need is substantive freedom, not just nominal freedom at the level of licensing terms.
Suppose there is such a program, it has no documentation, the way the code is written, and it is extremely difficult to understand. While it follows a free license, the realities remind us that it has nothing to do with freedom and autonomy at the user experience level. It is difficult for users to understand the internal operating logic of this program, and naturally cannot understand why it gives the final result. Combined with personal experience, I think this is typical nominal freedom—the "freedom" that exists only in the terms of the license and is completely absent in actual experience, and definitely not really free.
The experience with Emacs also made me realize that as a software community, our focus must always be on the end user, and we should not publish code that the user does not have permission to operate. Instead, we should be free to allow users to manage calculations autonomously. Free software is not just about replacing proprietary code, its more important symbolism is to motivate people to change their attitudes toward autonomous thought. The relationship between the community and the user is not only about giving and taking, but should also guide the user to get used to freedom and responsibility.
The ultimate goal of this is to free people from the copyright system that has long shackled us and exchange rights to users. Yes, code itself is not the ultimate goal, so the open source community must be brave enough to step out of the formulaic copyright file. A one-size-fits-all approach of "accept or give up" neither empowers users nor fosters their autonomy. A good project should not only be accessible, configurable, and well-equipped with documentation, but should also contribute to the development of the free cause.
The first step in advancing this cause is to break down software barriers and make all programs work together. Eventually, users will learn how to take charge of their entire computer so that everyone can truly be part of a new era of free software.
The Emacs community and my community contribution journey
Having said this for half a day Emacs, we actually have our own community. The Emacs community welcomes newcomers to spread knowledge and share ideas. The Emacs community has always had high demands on the quality of development and has made this a big deal about user freedom. Currently, the regular Emacs packages provide detailed documentation, allowing users to configure the experience they want with a variety of options.
The Emacs community is well aware that we cannot exert control over the initiative of end users. As a result, all relevant code has good extensibility and customization space. Communities have always held the view that freedom is an inter-subject experience unfolding, so it is not enough to deregulate at the legal level alone. As a result, Emacs promotes a strong documentation culture, where each Elisp form must be explained in natural language, and each feature pack must provide instructions for use and configuration. In this way, we want to guarantee a minimum amount of freedom of computing.
That's how Emacs does it, and it extends all the way to core applications. As a Lisp machine, Emacs was designed to empower end users from the start, revisiting all established rules. For example, my Elisp learning path started with writing small function footprints that adjust how certain default operations are performed. I'd like to add the functionality of the "move down a line" command to support moving down a specific multi-line. Emacs can evaluate code in real time and open up complete source code and related documentation. It was with this openness that I learned how to define functions and then write my first custom Elisp through trial and error.
After that, I continued to tweak Emacs in the hope of achieving minor optimizations that would benefit my day-to-day work. During this time, I gradually mastered Elisp and used this new knowledge to operate Emacs with ease. Over the past two and a half years, I've written thousands of lines of Elisp and contributed to the core Emacs, including two fully accessible, customizable themes, which are modus-themes.
To put it another way, I learned more programming in my first three months as an Emacs user than I had in the previous three years in the free software community. For me, this is the best example of a community leading end users to grow and meet their needs. I used to know nothing about technology, but now I've mastered programming and started trying to gain autonomy in computing. While there is still a long way to go, I have at least taken a step forward.
Reference Links:
https://protesilaos.com/codelog/2022-03-22-libreplanet-emacs-living-freedom/
Recently InfoQ will do an interview with Prot, if readers and friends have content they want to know or ask questions, they may wish to actively leave a message in the comment area.
![Win11 wants to change starting with Notepad[fig]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)