New GitHub Repository of Proven Mainframe Solutions (Part Two)
No more long searches for complex mainframe solutions.
No more desktops covered in sticky notes with commands scrawled on them.
No more tracking down and hounding your senior colleagues for answers.
No more long, boring crawling through documentation and forums.
And no more patchwork solutions to mainframe problems.
We have developed an open-source repository for “all things mainframe”, and this article will show you how to use it to simplify your search for solutions.
Table of contents
This is the second and final part of a series on our mainframe repository.
In part one, we explored why and how we built our repository.
We built our repository to solve a simple problem — historically, mainframe has been a very siloed, closed discipline. Everyone in the mainframe community has built their own solutions and kept most of their information to themselves. This is no one’s fault, it’s just the culture that’s developed.
But because mainframe has developed in such a siloed manner, it has been historically difficult to find new solutions to new problems. If you encountered a new problem, you had to perform a long, boring, and frustrating search for a solution. And often, you would not even find an answer to your issue.
We encountered this problem a lot at IBA, so we decided to solve it internally. We collected all of our mainframe solutions and put them in a single shared git. Creating this unified home for “all things mainframe” worked so well that we decided to make our repository open-source and share it with others.
You can access our repository here.
But if you’d like to learn more about how to use it, then read on.
In this article, we will explore:
- The most common ways you can use the repository.
- Two detailed, step-by-step examples of using the repository.
- How to get started using the repository in the right manner for you.
As a whole, we have made the repository as easy-to-use as possible.
We made information convenient to find by dividing it into topics, by applying intuitive structuring, and by allowing quick search on every page.
We deliberately named topics, section titles, and sub-paragraphs in the simplest and most obvious ways that we could from a searcher’s perspective.
We have placed all of its materials in the classic hierarchy of directories and files. We further organize topics using separate wiki pages and an additional sidebar navigator to easily transition from one topic to another.
From there, we have also incorporated features and functions that drive the five most common use cases we have seen for these types of repositories.
You can easily use the repository to:
- Subscribe to Updates or Bookmark the Repository Page
- Clone or Download the Repository
- Fork the Repository on GitHub and Edit for Your Needs
- Add Public Materials, Examples, Scripts, and Templates
- Add Questions, Comments, and Suggestions via GitHub
Let’s look at each use case in greater depth.
Subscribe to Updates or Bookmark the Repository Page
First, you can simply use the repository as a knowledge base.
This is the repository’s primary purpose — to provide a unified home for “all things mainframe” where you can find commands, scenarios, examples, templates, and approaches to make your life easier.
Now, we want to be clear that the repository will not have a solution to every problem you encounter, and we do not expect to fully replace all of the other sources of mainframe information out there. But you will find many answers to many questions in the repository, and it will give you a first place to look that will prevent you from going through many long, conventional searches.
In addition, the repository gives you a single knowledge base where you can casually learn more about mainframe, develop your general knowledge, and improve your skills even when you don’t have a specific problem to solve.
To use the repository in this manner, you can either just refer to it as needed, you can browse it as a general learning center, or you can subscribe to it and receive alerts whenever there is an update or new content loaded.
Clone or Download the Repository
Next, you can personalize the repository to suit your specific needs.
By cloning and downloading the repository, you can use the repository offline as your own local, customized knowledge base. You will be able to edit the content for yourself, add your own files, and delete files you find unnecessary.
This allows you to always have quick and convenient access to our mainframe solutions, and it also gives you a secure version control system. If you create a clone, you will be able to add your own private mainframe solutions from your own notes without worrying they will be deleted or changed by other users.
Fork the Repository on GitHub and Edit for Your Needs
You can also create your own private version of the repository — while maintaining the ease of use of the GitHub web interface — by forking it.
By forking the repository, you can adapt it for your own needs without creating an offline version. You can make your fork of the repository private and only share it with members of your own team or other select individuals. In essence, you can use our public repository as the basis for your own private repository.
Within your private fork of the repository, you can load information that you cannot publish publicly, you will be able to edit existing content without impacting the version of that content that lives in our public repository, and you can overall construct your own personal online mainframe GitHub.
In this way, you can take all of the notes you have personally accumulated, and consolidate them in a platform and format that you can easily navigate and search to find your own answers faster than rifling through your papers.
Add Public Materials, Examples, Scripts, and Templates
You can also share your own materials with the rest of the mainframe community by posting them on the public repository. You can add anything that you’ve developed that others might find useful, including commands, cheat sheets, tips and tricks, scripts, and templates. In addition, you can suggest changes or comments to existing materials. Everything helps.
However, please note that the repository is not ungated. We review every submitted item to make sure it complies with our core principles, and that it delivers real, useful value for the rest of the mainframe community. But as long as a submission meets the criteria we outlined in post 1, we will include it.
So, if you have materials you feel will add value, then you can request to add them to the repository by creating a “Pull Request”. Within this request you will place the added materials, comments, or suggested edits that you’d like to see become part of the public repository, and we will review it all promptly.
Add Questions, Comments, and Suggestions via GitHub
This use case builds on the previous, and provides a little more detail.
If you search our repository for a specific solution to a specific problem, and if you do not find a viable solution, then you can quickly and easily create an issue with the appropriate title. You can share your ideas for what’s missing, make a suggestion, or outright ask the question that you were searching for.
You can also use this function if you notice an inaccuracy or error in any piece of material that currently lives in the mainframe. We want to make sure every piece of material works perfectly, so we welcome these concerns and issues.
Every time you create an issue in the repository — no matter what type of issue it is — we will try to help as soon as possible. Either we will help directly, or another user of the repository will help. (And, of course, you can also respond to issues raised by other users if you have a solution for them.)
While these are the most common use cases we have seen for the repository, there are many more ways you can leverage our platform. We chose to host our repository on GitHub because it is a very flexible, agile, and modern tool, and it provides users a wide range of options to customize their deployment.
With that in mind, let’s review a more detailed use case of the repository to help you better understand how GitHub works, and how you might leverage it to meet your unique needs.
Let’s start by breaking down a simple example of how to use the repository.
In this example, a user doesn’t know how to include a library in their current LOGON session (or they used to know how, but they forgot).
Here are the steps they would follow to find the answer in the repository.
- To start, they will open the repository. They will then use Ctrl + F to search the page for the information they are interested in. They search for how to include the library in the current LOGON sessions.
- They find the information they are looking for. In this particular example, it’s a list of actions they must perform to include the library.
- They don’t want to touch the LOGON settings for all users, so they attempt to dynamically add the library to their LOGON session.
- From here, in the repository they will learn how to add any required library (for example MYLIB.EXAMPLE).
- They will now go to the TSO session and execute the proposed command, and see MYLIB.EXAMPLE was added to the LOGON session dynamically.
- The command executes, and the process is complete. By using the repository, this user was able to find the solution to their problem, and to implement that solution, in a fraction of the time it would have taken if they had followed conventional approaches to finding their answers.
Now, let’s look at a slightly more detailed and complex example.
A user is leveraging the Jenkins IBM z/OS Connector plugin. This allows them to run JCL jobs on z/OS. The user wants to quickly test how convenient this plugin is before they leverage it for more complex automation use cases.
Again, they open the repository, and search for the specific information they need on this plugin. The repository would provide them with information and step-by-step guidance on how to install and setup the plugin, as well as a user guide on how to leverage the plugin to execute small jobs, such as a “Hello World” script. From one of the repository’s GitHub wiki pages a user would be able to quickly get up to speed with a great new plugin by downloading its sources, installing it, configuring it, and trying it out with a real-world test.
At this point, you have a clear picture of what you can do with the repository we built, as well as the nuts and bolts of how to use it to solve your problems.
And now it’s time to just get started and to find the right use case for you.
Of course, we understand that this is easier said than done. Using the repository will be a new way of working for many people in the mainframe community. It might feel challenging to trust the information inside, or to contribute your own solutions that you have traditionally kept private.
However, we also believe this repository represents a needed evolution for the mainframe community. It will help modernize mainframe and bring many of the benefits and best practices of modern technology approaches into our discipline. It will make us more open, more agile, and more effective.
But our repository can only help mainframe evolve if enough people join us in this project. The repository will only grow, provide more value, and become a truly trusted resource if more members of our community contribute to it.
We plan to continue to expand the repository both horizontally and vertically by adding to the existing content of the repository, and by taking it in entirely new directions. But we still need your contributions to make it truly great.
So, take a few moments today to explore the repository, and to find the right use case for your unique situation. Access materials for your own personal tasks. Create and develop your own private systems. Or become a public contributor to our project. Whatever works for you, just get started.
If you use the repository regularly, we know you will be able to:
- Reduce your time spent research mainframe solutions.
- Avoid the pitfalls we fell into developing these solutions.
- Rapidly access and deploy working code templates and examples.
- Help the development of the mainframe technology and community.
To do so, just click here to access our repository.
Or you can reach out to us directly to discuss the project in greater depth.
You may also be interested in
- How to Break Your Cycle of Constant Firefighting and Embrace Proactive Management
- How to Break Your Cycle of Constant Firefighting and Embrace Proactive Management (Part Two)
- The Key to Large-Scale Mainframe DevOps Transformation: Building the Right Dedicated Team
- Choosing the Right First Steps in DevOps Mainframe Transformation
- Improving the Initial Automation and Creating a “Two Button Push” Process
- How to Select and Implement the Right Tools for Mainframe DevOps Transformation
- Picking the Right Tools: A Deep Dive Into the Most Popular Options for Mainframe DevOps