Lessons Learned from Cultivating Open Source Projects and Communities

Over the last decade, I’ve had the privilege professionally of building and cultivating some Open Source projects and communities. To start off this isn’t a tools talk, this is a talk about the soft skills you have to have to be able to succeed as a leader in an Open Source project. My journey started tending the frequently asked questions for a small Linux Distribution called CRUX, and then years later professionally moved to the OpenStack-Chef project to build OpenStack clouds. I’ve grown other projects along the way, helped build tooling and communities, some successful and still running today, others were just flashes in the pan. I’ve learned a ton on this journey; honestly still am, but I have some lessons that are hard-learned and hopefully I warn pitfalls that can cause wasted cycles and pain. I’ll be going over:
Outline
This isn’t a tools talk
Scoping your project
Personally-backed
Corporate-backed
Empathy and audience is important
Celebrations
Defeats
Successful traits of Open Source projects
Trust
Clear Vision
Have a plan to move on if needed
Honestly, is it even worth this hassle?

Cloud Native Application Development with Kubernetes and OpenShift

Cloud-native revolutionized the way we look at app development and is now one of the most popular programming architectures. OpenShift alongside Kubernetes is changing the way teams look at deployments of these microservices. Kubernetes provides powerful production-grade orchestration for your microservices.
In this talk, you’ll get an overview of Kubernetes, and move directly into leveraging OpenShift to what it provides for application development. You’ll then go through the process of building and deploying a microservice application in this cloud-native way.

Migrating a monolith to Cloud-Native and the stumbling blocks that you don’t know about

So your company has finally decided to move to the Cloud Native ecosystem. You’ve landed on containerization as your first step. You heard that all you needed to do was containerize your first app and then push it to Kubernetes/OpenShift/Nomad, and the cost savings just come. You’ve done this, and well, things have gone not as planned. Some of the tech didn’t do what you expected, and wait, what do you mean our OpEx has gone up?
Simply said: the promise of containerization or migrating to the Cloud Native ecosystem can be a lie if you don’t do your homework. Sadly most companies don’t. In this talk, I’ll explain a few gotchas that a “few” enterprises, in the guise of AsgharLabs, hit moving towards the Cloud Native world, and hopefully, you’ll learn from their mistakes, so you’re trip down this path will be more comfortable and closer to the promise.

Outline
Introductions
What is AsgharLabs and where they started, what they thought they needed to do
Where I came into the conversation to help AsgharLabs
Questions you should ask after getting your app containerized
Where are the architectural advantages and disadvantages?
Are we doubling up on things?
Isn’t automation good here? Why is this thing so complicated now?
Questions you should ask about the cultural shift that will happen
How the economics of the Cloud can differ from your Datacenter
What do you mean our support is now Stack Overflow?
What do you mean our goal is to move away from the CCB?
Some tangible things you can start with to help become more successful
Build that pipeline extension
Collaborate with other teams
Visibility and Monitoring
Conclusion and where you can go from here

Deploying a simple (Python) app to Kubernetes/OpenShift

JJ will walk you through deploying a simple python application to Kubernetes/OpenShift. We’ll start from the ground up, then get a complete automated build. The goal is to enable your developers to focus on code, not the infrastructure! It’s a chance to see the power of OpenShift and why taking the time to learn cloud-native development can get you the velocity you need.

This doesn't have to be python per se, also I can teach this as a workshop or a presentation.

We accidentally created a Serverless Application

As a developer advocate, one of the largest challenges we have is teach people how to use our products. To do this is that we have to create workshops and disposable environments so our students can get their hands dirty. As IBM employees we use the IBM cloud, but it is designed for long-term production usage, not the ephemeral infrastructures that a workshop would require. We have previously created some systems around it to provide different ways of building up these systems, but in this latest iteration, we discovered we created a full serverless stack (by accident).

Outline

Introduction
Our problem
Our iterations
Where serverless came into play
Our code
Where we can go from here
Was it worth it?

Introduction to Leveraging AI for Your Enterprise

With the emerging AI space, for enterprises, you need to know many terms and concepts before venturing into it. In this session, we will start with the foundational terms and experiences you must have to find the positives to leverage WatsonX to win in business. We will also demo some straightforward but valuable examples to help anchor your understanding. Our goal for this talk is for you to walk out of the room with the language (funny, eh?) and understand the typical workflow to start finding places to leverage WatsonX in your enterprise. The first step on this journey is to know the ecosystem and tooling; from there, you can find things to fit your business and get you on the road to success.

## Outline
- Introductions
- What do you need to know to start
- Let’s talk AI
- Consumer
- Business
- Let’s talk AI terms
- Model
- Training
- Types of Models
- sentiment
- summarization
- text generation
- image classification
- How can Enterprises can make this work
- Positives
- Negatives
- Demo
- Sentiment
- Summarization
- Image Classification
- cached
- downloaded
- Conclusions