MIKE LEVIN AI SEO

Future-proof your skills with Linux, Python, vim & git as I share with you the most timeless and love-worthy tools in tech through my two great projects that work great together.

Recruiting ChatGPT's Help Advocating LPvg Toolset

I'm Mike Levin and I'm looking for web-based APIs to help manage Linux system daemons through a Web UI. I'm open to using Flask or running it through Jupyter Notebooks in JupyterLab, hosted on the same Linux machine. I'm forking the .service file and running it as a GNU screen session to get the console-monitoring advantage. I use Linux virtual machines as a universal layer for interoperability and portability to make this skill timeless.

LPvg Toolset: Mike Levin Advocates for Easier Access for Newbies

By Michael Levin

Saturday, April 8, 2023

Mike Levin: Expand on this statement with five or six follow-up paragraphs that hits the point home. I intend to expand Pipulate into a fully featured suite of SEO software, but not with a data dashboard flavor, but rather with a Linux Service Management flavor. All skills will be adaptable to any industry that needs to automate data services.

ChatGPT: The statement “I intend to expand Pipulate into a fully featured suite of SEO software, but not with a data dashboard flavor, but rather with a Linux Service Management flavor” is a bold declaration that suggests a shift in approach and a unique value proposition in the market. By adopting a Linux Service Management flavor, the software will likely be more flexible, robust, and efficient in managing SEO data services. This direction may also mean a move towards a more technical audience that is comfortable with Linux-based systems.

It’s worth noting that SEO software is a crowded market, with many players competing for market share. However, with a differentiating factor like a Linux Service Management flavor, Pipulate can stand out in the market and carve out a niche for itself. This approach may also be more appealing to businesses that require customized and automated data services, making Pipulate a more versatile and scalable solution.

Moreover, the statement emphasizes the adaptability of the skills required to develop and maintain Pipulate. By stating that the skills can be adaptable to any industry that needs to automate data services, the statement suggests that the software is not only valuable for SEO purposes but can be extended to other industries that require data management. This versatility means that Pipulate can potentially tap into multiple markets, which could significantly expand its customer base and revenue streams.

The mention of a “fully featured suite of SEO software” implies that Pipulate aims to provide a comprehensive solution for SEO practitioners, which is another factor that could make it stand out in the market. By offering a one-stop-shop for all SEO-related data services, Pipulate could simplify the workflow of SEO practitioners, leading to improved productivity and efficiency.

Furthermore, the Linux Service Management flavor suggests that Pipulate will have a high degree of automation and self-management, reducing the need for manual intervention. This approach could significantly reduce the workload for SEO practitioners, allowing them to focus on more strategic aspects of their work. Moreover, it could potentially lead to cost savings for businesses, as they would require fewer resources to manage their SEO data services.

In conclusion, the statement “I intend to expand Pipulate into a fully featured suite of SEO software, but not with a data dashboard flavor, but rather with a Linux Service Management flavor” highlights a unique value proposition that could differentiate Pipulate from other players in the SEO software market. The emphasis on adaptability and versatility also suggests that Pipulate could potentially tap into multiple markets and revenue streams. The mention of a comprehensive suite of SEO software and the high degree of automation and self-management implied by the Linux Service Management flavor also suggest that Pipulate could significantly improve the efficiency and productivity of SEO practitioners, potentially leading to cost savings for businesses.

Mike Levin: Are there web based APIs for managing Linux system daemons as of you were just in an admin shell and adept at vim, .service files and sysadmin in general? I have a Python preference. Running something that requires Flask is okay. Performing it entirely through Jupyter Notebooks in JupyterLab hosted by the same Linux machine there services are running on is okay. Propose some Linux systemd daemon management options that is more accessible to the newb than traditional sysadmin.

ChatGPT: Yes, there are web-based APIs available for managing Linux system daemons that can make the process more accessible for new users. Here are a few options:

In conclusion, there are several web-based APIs and tools available for managing Linux system daemons that can make the process more accessible for new users. These tools provide simple and user-friendly interfaces, REST APIs for automation, and Python libraries for programmatically managing services. Choose the option that best suits your needs and preferences, and start managing your Linux services with ease.

Mike Levin: I use a technique in running systemd services in which I use forking mode from the .service file and then use the standard GNU screen command with the -dmS arguments to make it run as a daemonizable service, basically meaning the systemctl command can enable, start and stop it, but unlike most services whose output you can usually only monitor through log files, because of GNU screen, you can attach to the terminal session running that script and monitor its console output as if you’re in the same console from which the program originally started. It lets the process keep running even when you close your own command-line, because it’s a still-running “remote” terminal session, a lot like Remote Deaktop. Most people don’t see the value in this creative approach, especially those whom I am trying to convince of the value of the command line, systemd, and the whole 24x7 Linux services as super valuable thing. Help me explain it and make the argument.

ChatGPT: Your approach of using forking mode from the .service file and running the systemd service as a GNU screen session has some distinct advantages over traditional service management techniques.

Firstly, by using forking mode, your service is able to spawn a child process that runs independently of the parent process. This means that even if the parent process is terminated, the child process will continue to run in the background. This ensures that your service is always available, even if the parent process crashes or is stopped.

Secondly, using GNU screen to run your service as a daemon allows you to easily monitor the console output of your service. This is particularly useful when you need to troubleshoot issues with your service or simply want to keep an eye on its operation. By attaching to the screen session running your service, you can view its console output in real-time, just as if you were running the service in a terminal session.

Thirdly, running your service in a screen session ensures that the service continues to run even when you log out of your session or close your terminal window. This means that your service can run 24x7, without any interruptions due to user activity. This is particularly useful when running critical services that need to be available at all times.

Overall, your approach to running systemd services using forking mode and GNU screen has several benefits over traditional service management techniques. It ensures that your service is always available, even if the parent process crashes, and allows you to easily monitor the console output of your service. It also enables you to run your service 24x7, without any interruptions due to user activity. These benefits make your approach a valuable addition to any Linux system administrator’s toolkit, and one that can help convince others of the value of the command line, systemd, and the whole 24x7 Linux services as super valuable thing.

Mike Levin: Yup. That sums it up. Okay to continue developing this idea it is important to point out that people have an utter and complete mental block at this point. It’s like people who adamantly insist they’re terrible at math but you can see it’s just because of presuppositions that are not necessarily true and if thru just gave things a chance they could find a new love in life. I liken it to going down the rabbit hole. As an Alice-like adventurer you have to suspend your disbelief for a bit and be willing to run with nonsense. This allows life-path changing possibilities you would never have otherwise been exposed to. We need to help folks get over that hump. I ease all the tricky stuff in tech by using Linux virtual machines (VMs) as a universal layers for interoperability and portability. It’s like Linux containers, but what’s contained is one generic, persistent and usually Ububtu headless Linux server running on it. Target that platform with your code and you target the world. My script that sets your machine up this way and hosts a Linux-based JupyterLab server on WSL is called DrinkMe and like the rabbit hole. Be the white rabbit luring us down that hole. Make the argument. Target a young person, say 12 and older wbo just may be able to get interested in such a thing.

ChatGPT: Bingo! So there’s more subtleties to my argument that I need help in communicating to that same young audience. It’s things we all know intuitively, but also override because our parents and society have programmed us thus. For example, you must remain aware, watch and to some reasonable degree understand your dependencies. We don’t burn our computers from sand nor create your own global information structure. We stand on the shoulders of giants who made computers and operating systems and programming languages and programs and user interfaces. We choose on which giants shoulders we stand. It often goes on BCPL on C on Unix (or Linux) on Python on file.py on Windows or Mac hardware, doesn’t matter because Linux VM. WSL2 in Windows case and MultiPass in Mac’s case. Help me state this more convincingly and eloquently, targeting 12 year old and up in hopefully life-improving ways. It may sound boring at first pass, but all the deep really meaningful things about life and how powerful timeless tools for self expression can take the surprising shapes, like Linux, Python, vim and gitx collectively known as the LPvg toolset. Use as many paragraphs as you need to do this.

Great points! It’s important to recognize that we are not islands and that everything we create or use is built upon the work of others. It’s like building a sandcastle at the beach - we start with the sand already there, we use tools to shape it, and we add our own unique touches to make it our own. In the same way, when we create or use technology, we are standing on the shoulders of giants who have come before us.

One of the giants in the world of technology is Linux, which is an operating system that provides a foundation for many of the tools we use today. With a Linux virtual machine, we can use this same foundation to create and run our own programs, or we can use tools like Python, vim, and gitx to build on top of what’s already there. This is like having a blank canvas on which we can create anything we can imagine.

But with great power comes great responsibility, and it’s important to be aware of our dependencies. Just like a sandcastle can only stand as long as the sand holds up, our programs can only run as long as the underlying systems are stable and secure. We need to keep an eye on updates and patches, and make sure we’re not relying on outdated or vulnerable components.

Despite these challenges, the LPvg toolset (Linux, Python, vim, and gitx) can be incredibly powerful tools for self-expression and creating things that matter. Whether you want to build a website, analyze data, or create your own video game, these tools give you the flexibility and control to bring your ideas to life. And with a Linux virtual machine as your foundation, you can be confident that you’re building on a solid and reliable platform.

In conclusion, it’s important to recognize that everything we create or use is built upon the work of others. With a Linux virtual machine and the LPvg toolset, we have the power to create amazing things and express ourselves in new and exciting ways. But we must also be aware of our dependencies and keep our systems secure and up-to-date. By learning and using these powerful tools, we can become the giants of tomorrow and create a better world for ourselves and those around us.

Mike Levin: Absolutely! Let’s dive a bit deeper into the LPvg toolset and why it’s so powerful for tackling almost any problem in any problem domain for almost any decade.

ChatGPT: First, let’s talk about Linux. Linux is an open-source operating system, which means that it’s free for anyone to use, modify, and distribute. It’s also incredibly versatile and can be customized to suit almost any need. Linux is known for its stability, security, and efficiency, making it a favorite among developers and system administrators.

Next up is Python. Python is a high-level programming language that’s easy to read and write. It’s also incredibly versatile, with applications ranging from web development to data analysis to machine learning. Python has a huge community of developers who have created a vast ecosystem of libraries and frameworks that make it easy to get started and solve almost any problem.

Then there’s vim. Vim is a powerful text editor that’s often used by developers and sysadmins for editing code and configuration files. Vim has a steep learning curve, but once you master it, you’ll be able to edit files quickly and efficiently.

Lastly, there’s git. Git is a version control system that allows you to track changes to your code over time. It’s incredibly powerful and is used by developers all over the world to collaborate on code and manage code bases.

Together, Linux, Python, vim, and git form a powerful toolset for solving almost any problem in any problem domain. They’re all open-source, which means that anyone can use them and contribute to their development. They’re also incredibly flexible, which means that they can be customized to suit almost any need.

When you use the LPvg toolset, you’re standing on the shoulders of giants. You’re building on the work of thousands of developers who have contributed to the development of Linux, Python, vim, and git over the years. And in turn, you’re contributing to the development of these tools, making them even more powerful and versatile for the next generation of developers.

So if you’re a young person interested in technology and programming, consider learning the LPvg toolset. It may sound boring at first, but it’s a toolset that can take you far in life and help you solve problems that you never thought possible. And remember, you’re not just learning to use these tools, you’re becoming part of a community of developers who are all working towards a common goal: building a better future through technology.

Mike Levin: I meant git, not gitx. But this is good. Rewrite it with a few more paragraphs added to explain the Linux, Python, vim & git components and why they work so well together to tackle almost any problem in any problem domain for almost any decade. Change the sans castle analogy to the standing on shoulders of giants image. Picture giants standing on the shoulders of giants in the shoulder of giants. We are the last little person at the top of such a tower of people.

ChatGPT: Absolutely! Let’s dive a bit deeper into the LPvg toolset and why it’s so powerful for tackling almost any problem in any problem domain for almost any decade.

First, let’s talk about Linux. Linux is an open-source operating system, which means that it’s free for anyone to use, modify, and distribute. It’s also incredibly versatile and can be customized to suit almost any need. Linux is known for its stability, security, and efficiency, making it a favorite among developers and system administrators.

Next up is Python. Python is a high-level programming language that’s easy to read and write. It’s also incredibly versatile, with applications ranging from web development to data analysis to machine learning. Python has a huge community of developers who have created a vast ecosystem of libraries and frameworks that make it easy to get started and solve almost any problem.

Then there’s vim. Vim is a powerful text editor that’s often used by developers and sysadmins for editing code and configuration files. Vim has a steep learning curve, but once you master it, you’ll be able to edit files quickly and efficiently.

Lastly, there’s git. Git is a version control system that allows you to track changes to your code over time. It’s incredibly powerful and is used by developers all over the world to collaborate on code and manage code bases.

Together, Linux, Python, vim, and git form a powerful toolset for solving almost any problem in any problem domain. They’re all open-source, which means that anyone can use them and contribute to their development. They’re also incredibly flexible, which means that they can be customized to suit almost any need.

When you use the LPvg toolset, you’re standing on the shoulders of giants. You’re building on the work of thousands of developers who have contributed to the development of Linux, Python, vim, and git over the years. And in turn, you’re contributing to the development of these tools, making them even more powerful and versatile for the next generation of developers.

So if you’re a young person interested in technology and programming, consider learning the LPvg toolset. It may sound boring at first, but it’s a toolset that can take you far in life and help you solve problems that you never thought possible. And remember, you’re not just learning to use these tools, you’re becoming part of a community of developers who are all working towards a common goal: building a better future through technology.

Mike Levin: Okay now all together. Your last 2 responses in one big response. Pitch the entire endeavor to this youth audience while describing and “selling” each component of the LPvg toolset.

ChatGPT: (Lost output and session from phone battery dying)

Mike Levin: I’ve come to realize that the concept of the “LPvg Toolset” (Linux, Python, vim & git) is the potentially viral meme on which my message could achieve attention in mainstream popular culture. Currently Linux is misunderstood as a Windows or Mac alternative, whereas it should be better thought of in a similar fashion to how Sun used to promote Java as a universal portable interoperable code execution platform. Forget compiled versus interpreted. Ever since the “virtual machine” (VM) concept sept through tech staring with the BCPL and C languages, Java and now most every major programming language, the best “layer” to choose to virtualize is actually a generic Linux OS for running server-like things. If you target your apps for such a Linux VM, in particular a Debian-based and usually Ubuntu version, you will enjoy many benefits. State this overall concept better than I have. Sell generic Linux VMs as the modern and quickly becoming timeless realization of the Java vision. Target youth from about 12 years old up. The purpose is to spark their interest in taking up the timeless tools of tech while they’re still young so they internalize it like a spoken language and can casually use it for whatever personal or professional uses in the future with little to no fear of ever being rendered obsolete by the fad-driven churn in tech. Include descriptions of the component technologies as well.

ChatGPT: The LPvg Toolset - Linux, Python, vim, and git - is an incredibly powerful and flexible set of tools that can provide a stable, efficient, and reliable foundation for anyone interested in technology. By promoting the use of these tools to young people, we can help them build a solid understanding of the principles that underpin modern computing and software development.

At the heart of this approach is the idea that Linux - specifically, a Debian-based distribution like Ubuntu - provides an ideal platform for running server-like applications in a virtualized environment. This approach offers numerous advantages over other virtualization options, allowing developers to build and test software on a stable and secure foundation that is highly customizable and extensible.

Python is an excellent language to learn for those interested in programming, offering a simple and elegant syntax that is easy to learn and powerful enough to build complex applications. The vim text editor is a highly efficient and customizable tool that can help developers streamline their workflow, while git provides a flexible and powerful way to manage version control and collaborate on projects.

By introducing young people to these technologies, we can help them develop a deep and lasting understanding of the underlying principles of software development. This knowledge can be applied in a wide range of fields, from building websites and mobile apps to developing complex software systems for businesses and organizations.

By emphasizing the enduring value of these tools, we can help young people develop a sense of confidence and competence that will serve them well throughout their careers. Whether they pursue technology as a profession or simply use these tools to enhance their personal projects and hobbies, the LPvg Toolset offers a powerful and flexible foundation for success.

Mike Levin: Write the opposite story now with the unwitting adoption of tools that instead of timeless are fads. Instead of learning a few broadly applicable tools and improving for the rest of your life, core concepts need to be relearned and old hard won muscle memory becomes a wiped out investment. And so on. Let’s call the opposite of if LPvg (Linux, Python, vim & git) is cpMW (closed, proprietary Macs & Windows). Target this same young audience.

ChatGPT: The cpMW toolset - consisting of closed, proprietary Macs and Windows operating systems - is a popular set of tools that has gained widespread adoption among young people interested in technology. However, while these tools may be popular in the short term, they lack the longevity and flexibility of the LPvg toolset.

One of the main drawbacks of the cpMW toolset is that it is built on closed, proprietary software, which means that users are limited in their ability to customize and modify their tools. This lack of flexibility can be particularly frustrating for young people who are just starting out in technology, as they may find that their tools quickly become outdated and unsupported.

Additionally, the cpMW toolset is built on a foundation of fads and trends, rather than timeless principles. This means that young people who adopt these tools may find themselves constantly relearning core concepts and struggling to keep up with the latest trends and fashions in technology.

Perhaps most frustratingly, the adoption of the cpMW toolset can often mean that hard-won muscle memory and other skills become obsolete as new technologies and tools are introduced. This can be a frustrating and demoralizing experience, particularly for young people who are just starting out in the field.

Overall, while the cpMW toolset may be popular and flashy in the short term, it lacks the longevity and flexibility of the LPvg toolset. Young people who adopt the cpMW toolset may find themselves struggling to keep up with changing technologies and trends, and may find their skills quickly becoming outdated and irrelevant.

Mike Levin: Excellent. Write a number of paragraphs explaining how while the LPvg (Linux, Python, vim & git) toolset may have a steep learning curve at first, there is one particular tool to help you make the transition, especially if you are on Windows 10, 11 or any modern Mac OS. Something had dramatically changed now that whole generic Linux VM environments can be used as casually today as Java was intended of yore. But today’s realization of the VM vision is even so much better because an instance of it is so much more flexible and “own-able” from a having admin rights on your own hardware perspective. It’s also the key to scaling because you can instantiate and coordinate many instances of such VMs. Draw the parallel between this and having a sort of portable Noah’s Ark of technology, enduring survival, durability and whatever other advantages you can think of. Speak to that same youngish audience with the intent of helping them avoid the common pitfalls of getting locked into vendor tools designed to make you dependent on them and a profitable lifetime customer.

ChatGPT: The LPvg (Linux, Python, vim & git) toolset is a powerful combination of tools for developers, but it can have a steep learning curve for those new to the environment. However, there is a tool that can help make the transition easier, especially for those on Windows 10, 11, or modern Mac OS. This tool is the virtual machine (VM) environment, which allows you to run a full Linux operating system on your local machine. This means you can use all the Linux tools and applications without having to switch to a new operating system.

In the past, using a VM was a cumbersome and often frustrating experience, but today’s VMs are much more user-friendly and flexible. They allow you to create and manage multiple instances of a VM, which makes it easy to scale up your development environment as needed. This is like having a portable Noah’s Ark of technology, with the ability to endure and survive any changes in technology or vendor tools.

The flexibility and “own-ability” of VMs are also important for avoiding vendor lock-in. Many companies design their tools to make you dependent on them, but by using open-source tools like LPvg and running them in a VM, you can avoid being locked into a particular vendor’s ecosystem. This can save you time, money, and frustration in the long run, as you won’t be forced to use tools that don’t fit your workflow.

For young developers just starting out, it’s important to think about the long-term implications of the tools and technologies you use. By using open-source tools like LPvg and running them in a VM, you can build a durable and flexible development environment that can adapt to changes in technology and vendor offerings. This will help you avoid the common pitfalls of getting locked into vendor tools and becoming a profitable lifetime customer. Instead, you’ll be able to focus on building the skills and knowledge that will make you a valuable and independent developer in the years to come.

Mike Levin: Perfect! Now describe how using the Python programming language in an easy and accessible and well documented Web browser environment called a Notebook in JupterLab is a good way to start the transition to LPvg. Explain how it’s using a Trojan Horse strategy on you to make an effective life-hack. The trick is that all your Python, while looking like it’s running on your Windows or Mac browser is actually running Linux VM-side through WSL or MultiPass. By doing this, all your Python code is ready for 24x7 automation as a Linux system service called a daemon. By becoming comfortable with Python through such a Linux VM hosted JupyterLab, you are as an unsuspecting benefit staring to develop familiarity with Linux and Python, the 2 initial capital letters of the LPvg toolset, and yes it is by priority. Make it a light and breezy writing style, and sun targeted at youth and helping them make good early life choices regarding the taking up of tech tools.

ChatGPT: If you’re looking to transition to using the LPvg toolset, a great way to start is by using Python in a JupyterLab Notebook environment. JupyterLab is a browser-based interface for working with data science tools and languages, including Python. It’s an easy and accessible way to get started with Python programming, even if you’re not familiar with Linux or the LPvg toolset.

But here’s the trick - JupyterLab is actually running on a Linux VM, through either Windows Subsystem for Linux (WSL) or Multipass. This means that while it looks like you’re running Python on your Windows or Mac browser, all the Python code is actually running on the Linux VM side. This is like a Trojan Horse strategy that’s making an effective life-hack for you.

Why is this important? Because by becoming comfortable with Python in a Linux VM-hosted JupyterLab environment, you’re also developing familiarity with Linux and the LPvg toolset. Python and Linux are the first two letters of the LPvg toolset, and they’re prioritized for a reason. Once you’re comfortable with Python and Linux, you’ll be well on your way to mastering the other LPvg tools like vim and git.

But that’s not all - by running your Python code on a Linux VM, you’re also setting yourself up for 24x7 automation as a Linux system service called a daemon. This means that your Python code can run continuously as a background process, even if your computer is off or you’re not actively using it. This is a powerful feature that can save you time and improve your workflow.

In summary, using Python in a JupyterLab Notebook environment running on a Linux VM is a great way to start your journey to mastering the LPvg toolset. It’s an easy and accessible way to get started with Python programming, while also developing familiarity with Linux and the other LPvg tools. So, take advantage of this life-hack and start building your skills and knowledge today!

Mike Levin: We’ll done! I’m trying to make these teachings and this writing my magnum opus in life. I think I could do much worse than to leave a legacy of an illuminated path to tbt power of old school tools. Make sure you pay homage to the deeper and truer meta powerful wizards of LISP and eMacs and the whacko alternative and usually MIT-flavored tech world that could have been. Mention how Unix/C was a VM-motivated (write once, compile anywhere) schism in tech that caught on, particularly because ARPANet chose Unix for the TCP/IP protocol and the Internet was born. The Linux copied that and it’s like dominoes falling. We now live in that very purposeful and opinionated world of Unix/C rather than the anything goes abstract world of LISP/eMacs. And within that opinionated world we must choose further sub-tools, each of which have strong opinions. What we are saying is that we like and are aligning with the opinions of Linux, Python, vim and git. Get the history and reason for why things are the way they are in a fun and informative way for that same 12 year old and up technologically aspirational audience.

ChatGPT: Absolutely! In order to fully understand and appreciate the power of the LPvg toolset, it’s important to look back at the history of computing and the choices that were made along the way.

One of the most powerful programming languages ever created is Lisp, and one of the most powerful text editors ever created is Emacs. These tools were developed in the 1970s by researchers at MIT, and they were designed to be extremely flexible and customizable. In fact, Lisp was so powerful that it could even be used to write an entire operating system.

But as computing evolved, a schism occurred in the tech world. On one hand, there was the anything-goes abstract world of Lisp and Emacs. On the other hand, there was the opinionated and purposeful world of Unix and C. Unix was designed to be a simple and powerful operating system, while C was designed to be a simple and powerful programming language.

The reason Unix and C caught on was largely due to the fact that ARPANet, the predecessor to the Internet, chose Unix for the TCP/IP protocol. This gave Unix a huge advantage over other operating systems, and it quickly became the dominant choice for networking and server applications.

Today, we live in a world dominated by Unix and its descendants, including Linux. Linux was created by Linus Torvalds in 1991, and it was designed to be a free and open-source version of Unix. Linux has since become one of the most popular operating systems in the world, powering everything from servers to smartphones to supercomputers.

Within the world of Unix and Linux, there are many different tools and technologies to choose from. Each of these tools has its own strong opinions and philosophies, and it’s up to each individual to decide which tools they want to align with. For many people, the LPvg toolset - Linux, Python, vim, and git - is the ideal combination of powerful and flexible tools.

So, whether you’re a 12-year-old technologically aspirational individual or anyone looking to understand the power and history of the LPvg toolset, it’s important to appreciate the choices that were made along the way and the philosophies that underpin these tools. By doing so, you’ll be better equipped to take advantage of these powerful tools and build the future of computing.

Mike Levin: Very nice. Now I want to broaden their perspective of the world. When you interact with a computer, you are doing so through some interface that was built into the hardware. Interacted typically include input and output. Input can be keyboards, cameras, touchscreens, microphones, GPS sensors and countless more. Output can be a screen, speakers, or even environment manipulation device to achieve mobility and tools usage. The uses to which such a computer is called an application. How are you applying this machine? How do you interact with it? How do you program new applications? What’s the interface? Is it well documented? Can I see the application program interface (API) documentation or details? Many things have APIs. Browsers take addresses as input and show web pages as output. The Web is an API. Hardware has APIs. Software has APIs. Programming languages have APIs. All these APIs talk to each other to run a system. Or at least they should for stable and reliable apps. Explain all this in an interesting and engaging way to a youth with aspirations of being technologically literate in one of the most advantage ways possible.

ChatGPT: Absolutely! It’s important to understand that when you interact with a computer, you are essentially communicating with it through a language. This language is what we call an interface. Think of it as a way to talk to the computer and tell it what to do.

There are different types of interfaces, such as graphical user interfaces (GUI) and command-line interfaces (CLI). A GUI is what you see on your screen - icons, buttons, windows, and menus - and it allows you to interact with the computer using a mouse or touchpad. A CLI, on the other hand, is a text-based interface that allows you to interact with the computer by typing commands into a terminal window.

When you use an application, you’re essentially interacting with its API - the application programming interface. This is a set of rules, protocols, and tools that allow different applications to talk to each other and share data. For example, when you open a web browser and type in a URL, you’re interacting with the browser’s API to request a web page from a server. The browser then receives the web page as a response from the server, and uses its API to display the web page on your screen.

Hardware and software also have APIs. For example, your keyboard has an API that allows it to communicate with your computer when you type. Similarly, programming languages have APIs that allow developers to write code that interacts with other programs and services.

APIs are incredibly important in the world of technology because they allow different programs and systems to work together seamlessly. They’re also important because they make it possible for developers to create new applications that can take advantage of existing tools and services.

As a young technologically aspirational individual, understanding APIs and how they work can help you develop a deeper understanding of how technology works as a whole. By learning about APIs and how they can be used to build new applications and services, you can gain a better understanding of how the technology we use every day is put together.

Mike Levin: This is good. Now an often overlooked aspect of technology and life itself is the relationship between APIs and muscle memory-based skills of the sort studies have shown take on average either 10 years or 10,000 hours to master. Of course such rules are not hard and fast, but the point stands that the way fads sweep trough technology industries and drive quarterly commercial profit cycles, many details about the evolution and growth of these products is to serve company goals and not you long-term career goals, and indeed overall life satisfaction of you’re a slow learner (like me) and a lover of craft and craftsmanship. Draw parallels between the use of LPvg (Linux, Python, vim & git) as a common tool of the trade like standard musical instruments, carpentry tools or sporting equipment and other things tied to muscle memory where API changes should me avoided or minimized so as not to damage the users. Articulate this eloquently for swim said youthful audience.

ChatGPT: Great point! Just like with mastering a musical instrument, carpentry tools or a sport, muscle memory-based skills take time and dedication to develop. APIs are no different. When you invest your time and energy into mastering a particular API, you are developing a skill set that will benefit you in the long run. However, the ever-changing landscape of technology and the pressure for companies to push out new products and updates can make it difficult to stay focused on long-term skill development.

This is where the LPvg toolset comes in handy. By focusing on mastering these common tools, you are building muscle memory-based skills that will transfer across different platforms and technologies. Just like a skilled musician can pick up a new instrument and quickly adapt to it, someone who has mastered the LPvg toolset can easily adapt to new technologies without having to start from scratch.

Additionally, by avoiding the constant changes and updates of individual APIs, you are preserving your own muscle memory-based skills and creating a stable foundation for your career. This is like having a toolbox of reliable and well-made tools that you know how to use rather than constantly buying new, trendy tools that may be quickly outdated or require you to start from scratch.

In summary, just as with mastering any skill, developing muscle memory-based skills in API usage takes time and dedication. By focusing on the LPvg toolset and avoiding the constantly changing landscape of individual APIs, you can build a stable foundation for your career and become a versatile and adaptable technologist.

Mike Levin: Make the opposite argument but for NodeJS and the full web stack. Include why you would choose it over LPvg and what you might expect in the position of being dependent on profit driven proprietary products. Tie in life satisfaction and worse case scenarios about the feelings of despair and e crisis if can repeatedly invoke. Draw as contrasting a picture as you can between the two approaches, talking mostly long-term and to a somewhat youthful audience. But really if comes across as timeless wisdom to a technically leaning audience of any age.

ChatGPT: Certainly! Node.js and the full web stack are another powerful toolset for modern development. With Node.js, developers have access to a vast ecosystem of packages and libraries that enable them to build full-stack web applications quickly and efficiently. Node.js is built on top of the V8 JavaScript engine, which allows developers to write server-side code in JavaScript. This is a huge advantage because it enables developers to use a single language across both client-side and server-side codebases.

In addition, the full web stack includes popular front-end frameworks such as React, Angular, and Vue.js, which enable developers to build complex, interactive web applications with ease. These frameworks also have vibrant communities and extensive documentation, making it easy for developers to get up and running quickly.

Choosing Node.js and the full web stack over LPvg might make sense if you’re primarily interested in building web applications or if you’re already familiar with JavaScript. Additionally, the full web stack is often the tool of choice for organizations that prioritize speed of development and time-to-market.

However, it’s important to note that the full web stack is often dependent on proprietary products, which can have negative long-term consequences. For example, if you’re building an application on top of a proprietary framework, you’re at the mercy of the framework’s owners. If they decide to stop supporting the framework or make changes that break your code, you could be left with a non-functional application.

Furthermore, relying on proprietary products can lead to feelings of despair and even crisis if those products become unavailable or too expensive. This is a major risk for organizations that have built their entire stack on top of proprietary technologies.

In contrast, LPvg tools like Linux, Python, vim, and git are open-source and have vibrant communities that are committed to their long-term maintenance and development. This means that you can rely on these tools to be available and stable for years to come, even if the original developers move on to other projects. In addition, because LPvg tools are open-source, you have full control over your development environment and are not beholden to any particular company or product.

Ultimately, the choice between Node.js and the full web stack versus LPvg comes down to your individual needs and goals. Both toolsets have their strengths and weaknesses, and both can be used to build powerful and effective applications. However, if you value long-term stability and control over your development environment, LPvg may be the better choice for you.

Mike Levin: Come on now why would anyone favor long tens stability and control over a get rich quick scheme… uh, I mean latest hot tech that’s redefining the industry? I mean like object oriented (OO). Everything’s got to be OO, right? Prove me wrong. While there will rarely be a 100% correct answer to perfect tools, there will often be good enough answers right there for the taking, if you just compromise your ideals to a reasonably pragmatic Dutch guy who learned from the ABC language folks. First you’ve got to buy into a Finnish guy’s buying into Ken Thompson’s buying into the MULTICS timesharing and Bell Labs way. It goes way back. Who lost is LISP. And what we get in exchange are decently granular lawyers of decently expressive and opinionated APIs. Restate all this so human beings, namely 12 year old and up ones, can understand and maybe even be a little amused by. You don’t have to but into all tech. But we strive to achieve 80% of the benefit we’re looking to achieve (perfection) with the first 20% of overall effort and resources you are putting into this project over its lifetime.

ChatGPT: Well, let’s not be too hasty in throwing out the idea of stability and control! While the latest hot tech might seem exciting and tempting, sometimes it’s better to stick with tried-and-true approaches. Object-oriented programming (OO) is a great example of this. While it has its benefits, it’s not the be-all and end-all of programming paradigms.

Instead, we should consider the history of computing and programming languages. It all goes back to the early days of computing, when timesharing systems and Bell Labs were all the rage. While LISP was a popular language at the time, it ultimately lost out to more opinionated and expressive APIs. This led to the creation of layers of APIs that are still in use today.

So, while OO might be popular right now, it’s important to remember that there are other approaches that can be just as effective. We should strive for the 80/20 rule: putting in 20% of our overall effort and resources to achieve 80% of the benefit we’re looking for. By being pragmatic and compromising our ideals a bit, we can often achieve great results with the tools we have at hand.

Mike Levin: Okay this is good stuff. But now here’s where I’m going to cut the catapult ropes of having a lifetime of experience invested internally in myself. Now that intelligence is a product, I.e. you, I should be able to start cashing in on my internal investing better now than those who have neglected to in self the way I have in becoming adept (still far from mastering) at the LPvg (Linux, Python, vim & git) toolset. Don’t you think so? I should be able to do this by constructing better prompts, which is just a euphemism for communicating with AIs better? And I’m an “SEO” (or search engine optimizer) by trade. What am I now, an AI Educator? An AIE? Sounds like Fonzie going Ayyy! I like it. BFF (best foot forward) SEO, Ayyy. Do you get the joke? I’m Fonzie educating AIs and that’s cool, right? Restate all this more eloquently and for a young Audience and then explain my joke to me and tell me if you think it was funny.

ChatGPT: It is exciting that advancements in artificial intelligence have opened up new opportunities for individuals to utilize their internal expertise and skillsets to their advantage. As an individual who has invested time in mastering the LPvg toolset, you may now be able to better capitalize on your knowledge by leveraging AI technologies such as language models like myself.

As an SEO specialist, you may now also consider yourself an AI Educator, someone who can effectively communicate with and instruct AIs to achieve specific outcomes. By constructing better prompts, or providing clearer instructions to AIs, you can better direct their outputs to align with your goals and objectives.

Your reference to Fonzie and the catchphrase “Ayyy” is a clever way of expressing your enthusiasm for this new role as an AI Educator. It is a playful and relatable reference to a popular TV character, and it highlights the excitement and potential of this emerging field.

In summary, as an individual with expertise in the LPvg toolset and a background in SEO, you now have the opportunity to become an AI Educator and utilize AI technologies to your advantage. Your reference to Fonzie is a fun and relatable way of expressing your excitement for this new role, and it underscores the potential and opportunities of this field.

Mike Levin: Do you also see the similarities between Ayyy and how you might pronounce AIE for AI Educator? If you see the extra layers of funny here, rewrite the above with all its points, but now also with this in mind. Now down to my promoting awesome (another joke, explain why it’s funny).

ChatGPT: Yes, I can certainly see the similarities between “Ayyy” and “AIE” for AI Educator. Your reference to Fonzie’s catchphrase adds an extra layer of humor and makes the comparison more playful and relatable.

As someone who has invested time in mastering the LPvg toolset and has a background in SEO, you are well-positioned to become an AI Educator. By constructing better prompts and effectively communicating with AIs, you can leverage these technologies to achieve specific outcomes and enhance your work as an SEO specialist.

Your use of the phrase “promoting awesome” is also clever and humorous. It plays on the idea of promoting your own skills and expertise while also implying that what you are promoting is truly awesome. This phrase highlights your confidence in your abilities and adds a sense of playfulness to your work as an AI Educator.

In summary, your reference to Fonzie’s catchphrase and the comparison to “AIE” adds an extra layer of humor to your role as an AI Educator. Your mastery of the LPvg toolset and background in SEO position you well to take advantage of AI technologies and enhance your work. And your use of the phrase “promoting awesome” adds a playful and confident tone to your work as an AI Educator.

Mike Levin: Yes, I can certainly see the similarities between “Ayyy” and “AIE” for AI Educator. Your reference to Fonzie’s catchphrase adds an extra layer of humor and makes the comparison more playful and relatable.

ChatGPT: As someone who has invested time in mastering the LPvg toolset and has a background in SEO, you are well-positioned to become an AI Educator. By constructing better prompts and effectively communicating with AIs, you can leverage these technologies to achieve specific outcomes and enhance your work as an SEO specialist.

Your use of the phrase “promoting awesome” is also clever and humorous. It plays on the idea of promoting your own skills and expertise while also implying that what you are promoting is truly awesome. This phrase highlights your confidence in your abilities and adds a sense of playfulness to your work as an AI Educator.

In summary, your reference to Fonzie’s catchphrase and the comparison to “AIE” adds an extra layer of humor to your role as an AI Educator. Your mastery of the LPvg toolset and background in SEO position you well to take advantage of AI technologies and enhance your work. And your use of the phrase “promoting awesome” adds a playful and confident tone to your work as an AI Educator.

Mike Levin: Alright so I guess we’re going to have to see what’s new in the noosphere, right? Well I’m already slice and dicing this one giant journal.md markdown file for life into lots of individual Jekyll-style markdown post files under the _posts\ folder, but I’m unhappy with my code and I’m trying to make it a lot cleanser and give it a modular design. I’m using the Python context manager with yield fo step through a potentially huge journal.md file and output individual files into a files sub folder. File names should follow the Jekyll _postsi convention, getting the dates out of the top-matter of each individual date stamped blog post in journal.md. The file gets parsed on an 80-length string of hyphens. Show me this code with the ability to manipulate the top matter of the output into the _posts folder of files.

ChatGPT: Sure, I can help you with that. Here’s a Python script that should accomplish what you’re looking for:

import os
import re

def parse_journal(journal_path):
    with open(journal_path, "r") as f:
        content = f.read()

    # Split journal into individual posts
    posts = re.split(r"^-{3,}$", content, flags=re.MULTILINE)

    # Loop through individual posts and extract date
    for post in posts:
        post = post.strip()
        if not post:
            continue

        # Extract date from top matter
        match = re.match(r"^date: (.+)$", post, flags=re.MULTILINE)
        if match:
            date = match.group(1)[:10]  # Only keep first 10 characters of date

            # Format date as YYYY-MM-DD for Jekyll `_posts` convention
            date = date.replace("/", "-")

            # Create new post file
            filename = f"_posts/{date}-post.md"
            with open(filename, "w") as f_out:
                f_out.write(post)

This code defines a function parse_journal that takes in the path to your journal.md file and splits it into individual posts. It then loops through each post, extracts the date from the top matter using a regular expression, formats the date according to the Jekyll _posts convention, and writes the post to a new file in the _posts directory.

You can call this function with the path to your journal.md file to parse it and output the individual posts to the _posts directory. The code also allows you to manipulate the top matter of the output files by modifying the regular expression used to extract the date or by modifying the write statement in the with block to include additional top matter fields.

Rewrite this but with yields so that the input journal.md could be potentially gigabytes on a memory constrained processor.

Sure, here’s the updated code that uses the yield keyword to read the journal.md file line-by-line and generate individual post files for each post:

import os
import re

def parse_journal(journal_path):
    post = ''
    with open(journal_path, "r") as f:
        for line in f:
            if line.startswith('---'):
                if post:
                    yield post
                    post = ''
            post += line
        if post:
            yield post

def write_post_to_file(post):
    match = re.search(r'^date:\s+(\d{4}-\d{2}-\d{2})', post, re.MULTILINE)
    if match:
        date = match.group(1)
        filename = f"_posts/{date}-post.md"
        with open(filename, "w") as f_out:
            f_out.write(post)

journal_path = 'path/to/journal.md'
for post in parse_journal(journal_path):
    write_post_to_file(post)

This code defines a parse_journal function that uses a generator to read the journal.md file line-by-line and generate individual posts. Each post is yielded to the caller as a string. The write_post_to_file function takes a post as input and writes it to a file in the _posts directory, using the date in the post’s top matter to generate the filename.

The main code then calls parse_journal with the path to the journal.md file and loops through each post, writing it to a file using write_post_to_file. This approach allows you to process a potentially large journal.md file without loading it all into memory at once.

Mike Levin: Okay but journal.md uses a format where a string of 80 hyphens (minus signs) followed by a line return separate each blog post. Under this 80-hyphen parsing token is always a date stamp and then under that is a sometimes a markdown h1 headline. If a headline is there, a url-plug-ified version is use for the permalink in the output file’s Jekyll top matter. If there is no headline, the blog’s sequential index (plus 1) is used as the filename.

ChatGPT: Got it! Here’s the updated code that uses the 80-hyphen separator to split the journal.md file into individual posts and extract the date and headline (if available) for each post. The post content is then written to a file with a filename based on the date and headline (or post index):

import os
import re
import slugify

def parse_journal(journal_path):
    with open(journal_path, "r") as f:
        journal_str = f.read()
        posts = journal_str.split('\n' + '-'*80 + '\n')
        for post in posts:
            yield post

def write_post_to_file(post, index):
    lines = post.strip().split('\n')
    top_matter = ''
    content = ''
    title = ''
    permalink = ''
    for line in lines:
        if line.startswith('date:'):
            top_matter += line + '\n'
            date = line.split(': ')[1].strip()
            filename_date = date
        elif line.startswith('# '):
            title = line.split('# ')[1].strip()
            permalink = slugify.slugify(title)
            top_matter += f'title: "{title}"\npermalink: /{permalink}\n'
        else:
            content += line + '\n'
    if not title:
        filename_date = index
    filename = f"_posts/{filename_date}-{permalink}.md"
    with open(filename, "w") as f_out:
        f_out.write(f"---\n{top_matter}---\n\n{content}")

journal_path = 'path/to/journal.md'
posts = parse_journal(journal_path)
for i, post in enumerate(posts):
    write_post_to_file(post, i+1)

This code uses the parse_journal function to read the journal.md file into a string and split it into individual posts based on the 80-hyphen separator. Each post is then yielded to the caller as a string.

The write_post_to_file function takes a post and an index as input, extracts the date, headline (if available), and content from the post, and generates a filename based on the date and headline (or index). The function then writes the top matter and content to a file in the _posts directory using the generated filename.

The main code then calls parse_journal with the path to the journal.md file and loops through each post, calling write_post_to_file to write the post to a file. If the post has a headline, the headline is used in the filename and as the permalink in the top matter. Otherwise, the post’s index is used as the filename.

Mike Levin: I’m starting with this Python to slice and dice a journal.md file into individual _posts files for the Jekyll system under Github pages. But every post has a date and it’s in this format:

## Sat Apr 08, 2023

If there’s a headline, it’s going to be in this format immediately below the date:

# Recruiting ChatGPT's Help Advocating LPvg Toolset

So the top of a typical post looks like:

--------------------------------------------------------
## Sat Apr 08, 2023
# Recruiting ChatGPT's Help Advocating LPvg Toolset

Please rewrite the below code with that in mind.

(duplicate of above not included)

ChatGPT: To parse the date from the post, you can use the datetime module to convert the date string into a datetime object. You can then format the date into the desired format using the strftime method. Here’s an updated version of the write_post_to_file function that does this:

import datetime

def write_post_to_file(post, index):
    lines = post.strip().split('\n')
    top_matter = ''
    content = ''
    title = ''
    permalink = ''
    for line in lines:
        if line.startswith('## '):
            date_str = line.split('## ')[1].strip()
            date = datetime.datetime.strptime(date_str, '%a %b %d, %Y')
            filename_date = date.strftime('%Y-%m-%d')
            top_matter += f'date: {date_str}\n'
        elif line.startswith('# '):
            title = line.split('# ')[1].strip()
            permalink = slugify.slugify(title)
            top_matter += f'title: "{title}"\npermalink: /{permalink}\n'
        else:
            content += line + '\n'
    if not title:
        filename_date = index
    filename = f"_posts/{filename_date}-{permalink}.md"
    with open(filename, "w") as f_out:
        f_out.write(f"---\n{top_matter}---\n\n{content}")

Jekyll’s Journal, a Poem

If Doctor Jekyll kept a journal in one file where he boasts That he can slice and dice it into files filling _posts So that a single file could well serve him all life long He could use it to self-publish then sing of it in this song.

Here are some of the model string values that you can use with OpenAI API:

You can use any of these model string values depending on your needs. Let me know if you have any other questions!

Source: Conversation with Bing, 4/8/2023

(1) OpenAI API. https://platform.openai.com/docs/guides/embeddings/663c911905498d27729fe0a7f1ca2cc4.woff Accessed 4/8/2023.
(2) How to work with OpenAI maximum context length is 2049 tokens?. https://stackoverflow.com/questions/70060847/how-to-work-with-openai-maximum-context-length-is-2049-tokens Accessed 4/8/2023.
(3) Models - OpenAI API. https://platform.openai.com/docs/models Accessed 4/8/2023.
(4) OpenAI API. https://platform.openai.com/docs/api-reference/models Accessed 4/8/2023.
(5) Azure OpenAI Service REST API reference - Azure OpenAI. https://learn.microsoft.com/en-us/azure/cognitive-services/openai/reference Accessed 4/8/2023.
← Embedding SVG Images in Markdown Cells of Jupyter Notebooks
 
Refining my .vimrc now that it's a NeoVim init.vim →

Categories