marcd.dev

Publishing Github Java Packages to Maven Central for a New Domain

2021-03-19

Overview

🎉 The Solace Developer Relations team recently launched our SolaceCommunity github organization as a home for open source projects that are authored, maintained and supported by the amazing Solace Community. If you’re interested in joining our community you can read more about it here, but that won’t be the focus of the rest of this blog. The focus of this blog is how I enabled publishing of Java packges to Maven Central for this new github community and how you can do so for your own domain. Since Java is one of our most used languages, and most Java projects now leverage Maven or Gradle, I wanted to enable developers contributing their Java projects to be able to easily publish to Maven Central to make it easier for everyone in the community to easily use them. Over the past few weeks I went through the steps necessary to setup publishing of Java packages to Maven Central for the https://solace.community domain. This was trickier than I thought so I figured I’d share what I did to hopefully help others :)

I’m going to try to keep this short and to the point but feel free to let me know if you have any questions. I used the following resources when figuring out these steps so props to their creators!

Setting up OSSRH (The Repository)

There are a handful of approved repository hosting options specified by Maven Central. You can find the entire list here, but the easiest approach seems to leverage Open Source Software Repository Hosting (OSSRH) so that’s the approach I decided to take.

Note that if you’re just trying to publish a few personal projects on github and are fine publishing under io.github then you don’t need to follow all of these steps so I’d suggest heading over to google and doing a few more searches :)

Get An Account

The first step down this road is to register a OSSRH account. This account will be used to prove ownership of your domain (for publishing packages), but also to manage your repositories in the future. Sign up for an account here

✅ Account Created

Prove Domain Ownership

Now that you have an account the next step in the process is to prove ownership of the domain that matches the group that you’d like to publish to. Usually this is your domain name in reverse, so something like com.company if your domain is company.com. Since our developer community is at solace.community this meant we would publish to the community.solace group.

To prove that we own this domain I had to execute a few simple steps:

Open a New Project Ticket with OSSRH.
Follow the instructions request in the ticket to addd a DNS TXT record to our domain.
Wait a few hours (it says it could take up to 2 business days) for the DNS TXT record to be verified.
Check the ticket for confirmation that domain ownership has been confirmed.
Make a note to comment on this ticket after your first release to enable syncing to maven central!

✅ Domain ownership proven

Create Your User Token

Now that we have permission to publish to our domain we need to create a user token for publishing. This token will be used as part of the publishing process.

To get this token do the following:

Login to the OSSRH Nexus Repository Manager w/ your OSSRH account
Go to your profile using the menu under your username at the top right.
You should see a list menu that is on the Summary page; change it to User Token. You can create your token on this page.
Copy & Paste this token info so you can use it later! (Keep it private!)

✅ OSSRH is now ready to go and we have the info we need

Configuring the Maven pom

The next step is to setup our maven pom for publishing. Note that I used copy and paste programming to figure this out so I’m by no means an expert here :) If you are reading this and think I should include more detail here or my explanations are confusing please drop a comment and let me know.

An entire example pom can be found here

Here is what I did:

Ensured that my groupId starts with the reverse domain that we have approval to publish to! For example this is what we used, note that the groupId starts with community.solace.
```
 <groupId>community.solace.spring.integration</groupId>
 <artifactId>solace-spring-integration-leader</artifactId>
 <version>1.1.0-SNAPSHOT</version>
```
What to know about the version! Okay this is important. When publishing maven projects you have releases and you have snapshots. A “release” is the final build for a version which does not change whereas a “snapshot” is a temporary build which can be replaced by another build with the same name. Go ahead and google this if you want to learn more :)
Once you know the difference you’re ready to set your version. Use a version ending in a number, e.g: 1.1.0, for a “release” and end it in -SNAPSHOT, e.g: 1.1.0-SNAPSHOT for a snapshot.

Include a description name, description and url pointing to your repository. For example,

 <name>Solace Spring Integration Leader</name>
 <description>This project allows for Spring Integration Leader Election using Solace Exclusive Queues</description>
 <url>https://github.com/solacecommunity/spring-solace-leader-election</url>

Include a license, source control info scm, developers and organization(I believe this is optional) information.

 <licenses>
     <license>
         <name>MIT License</name>
         <url>https://github.com/solacecommunity/spring-solace-leader-election/blob/master/LICENSE</url>
         <distribution>repo</distribution>
     </license>
 </licenses>

 <developers>
     <developer>
         <name>Solace Community</name>
         <email>[email protected]</email>
         <organization>Solace Community</organization>
         <organizationUrl>https://solace.community</organizationUrl>
     </developer>
 </developers>

 <organization>
     <name>Solace Community</name>
     <url>https://solace.community</url>
 </organization>

 <scm>
     <url>https://github.com/solacecommunity/solace-spring-integration-leader.git</url>
     <connection>scm:git:git://github.com/solacecommunity/solace-spring-integration-leader.git</connection>
     <developerConnection>scm:git:[email protected]:solacecommunity/solace-spring-integration-leader.git</developerConnection>
     <tag>HEAD</tag>
 </scm>

Add a profile for OSSRH which includes the snapshotRepository info, the nexus-staging-maven-plugin, and the maven-gpg-plugin. Note in the example below I have this profile activeByDefault so you don’t have to specify it when running maven commands, however you may not want to do this. Depends on your use case :)

 <profile>
         <id>ossrh</id>
         <activation>
             <activeByDefault>true</activeByDefault>
         </activation>
         <properties>
             <gpg.executable>gpg</gpg.executable>
         </properties>
         <distributionManagement>
             <snapshotRepository>
                 <id>ossrh</id>
                 <name>Central Repository OSSRH</name>
                 <url>https://s01.oss.sonatype.org/content/repositories/snapshots</url>
             </snapshotRepository>
         </distributionManagement>
         <build>
             <plugins>
                 <plugin>
                     <groupId>org.sonatype.plugins</groupId>
                     <artifactId>nexus-staging-maven-plugin</artifactId>
                     <version>1.6.7</version>
                     <extensions>true</extensions>
                     <configuration>
                         <serverId>ossrh</serverId>
                         <nexusUrl>https://s01.oss.sonatype.org/</nexusUrl>
                         <!--  Change to true once we're good! -->
                         <autoReleaseAfterClose>false</autoReleaseAfterClose>
                     </configuration>
                 </plugin>
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-gpg-plugin</artifactId>
                     <version>1.5</version>
                     <executions>
                         <execution>
                             <id>sign-artifacts</id>
                             <phase>verify</phase>
                             <goals>
                                 <goal>sign</goal>
                             </goals>
                         </execution>
                     </executions>
                     <configuration>
                       <gpgArguments>
                         <arg>--pinentry-mode</arg>
                         <arg>loopback</arg>
                       </gpgArguments>
                     </configuration>
                 </plugin>
             </plugins>
         </build>
     </profile>

Include the maven-release-plugin, the maven-javadoc-plugin, the maven-source-plugin and the flatten-maven-plugin plugin.

 <build>
     <plugins>
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-release-plugin</artifactId>
             <version>2.5.1</version>
             <configuration>
                 <tagNameFormat>@{project.version}</tagNameFormat>
             </configuration>
             <dependencies>
                 <dependency>
                     <groupId>org.apache.maven.shared</groupId>
                     <artifactId>maven-invoker</artifactId>
                     <version>2.2</version>
                 </dependency>
             </dependencies>
         </plugin>

         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-javadoc-plugin</artifactId>
             <version>2.10.4</version>
             <executions>
                 <execution>
                     <id>attach-javadocs</id>
                     <goals>
                         <goal>jar</goal>
                     </goals>
                 </execution>
             </executions>
             <configuration>
                 <source>8</source>
                 <detectJavaApiLink>false</detectJavaApiLink>
             </configuration>
         </plugin>
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-source-plugin</artifactId>
             <version>3.0.1</version>
             <executions>
                 <execution>
                     <id>attach-sources</id>
                     <goals>
                         <goal>jar</goal>
                     </goals>
                 </execution>
             </executions>
         </plugin>
         <plugin>
             <groupId>org.codehaus.mojo</groupId>
             <artifactId>flatten-maven-plugin</artifactId>
             <version>1.1.0</version>
             <configuration>
                 <updatePomFile>true</updatePomFile>
                 <flattenMode>oss</flattenMode>
                 <pomElements>
                     <distributionManagement>remove</distributionManagement>
                     <repositories>remove</repositories>
                 </pomElements>
             </configuration>
             <executions>
                 <!-- enable flattening -->
                 <execution>
                     <id>flatten</id>
                     <phase>process-resources</phase>
                     <goals>
                         <goal>flatten</goal>
                     </goals>
                 </execution>
                 <!-- ensure proper cleanup -->
                 <execution>
                     <id>flatten.clean</id>
                     <phase>clean</phase>
                     <goals>
                         <goal>clean</goal>
                     </goals>
                 </execution>
             </executions>
         </plugin>
     </plugins>
 </build>

✅ The maven pom is now ready to go!

Create GPG Keys

The next step is to create a GPG key for signing the published packages. This allows for users of your project to verify the published package’s authenticity and trust using it in their own projects. In order to create a GPG key you will need to execute a few steps.

Create Your Key

The first step is to Create Your Key. You can do this locally using a tool such as gpg. Be sure to keep your private key private. If others get ahold of this they can become a trusted publisher of your packages.

Install the gpg tool; on mac you can do this by executing the command below. If you aren’t using a mac check out the instructions here
```
 brew install gpg
```
Generate your key pair. You will be prompted for a “Real Name” and “Eamil Address” that you want to use with the key
```
 gpg --gen-key
```

✅ GPG key created!

Now that you’ve generated your key pair, which consists of a private and a public key, you need to share the public piece. The public key will be used by developers to verify the package’s authenticity. You can also do this with the gpg command. It will share your key to a keyserver which tools such as maven know how to query to retrieve the keys for automated verification.

Get your keypair identifier. To do this you need to list your keys. The key will have an identifier that looks like a random string of characters, something like C48B6G0D63B854H7943892DF0C753FEC18D3F855. In the command below I’ve replaced it with MYIDENTIFIER to show it’s location.

MJD-MacBook-Pro.local:~$ gpg --list-keys
/path/to/keyring/pubring.kbx
----------------------------------------
pub   rsa3072 2021-03-11 [SC] [expires: 2023-03-11]
   MYIDENTIFIER
uid           [ultimate] solacecommunity <[email protected]>
sub   rsa3072 2021-03-11 [E] [expires: 2023-03-11]

Distribute to a key server using the identifier found in the previous step. Note that you may want to publish to a different keyserver. The one that worked for me was hkp://keyserver.ubuntu.com:11371
```
gpg --keyserver hkp://pool.sks-keyservers.net --send-keys MYIDENTIFIER
```

✅ We’ve now shared our public key!

Configure the Github Secrets

Okay at this point our project is looking pretty good and we could run a deployment locally using the mvn --batch-mode clean deploy command, however we actually want to perform our releases via a Github action. Shoutout to sualeh for creating this gist which helps me navigate the next few steps! In order to make the release from a Github Action we need to make our GPG private key and OSSRH user information available to the Github actions while also keeping it private. We can do this using Github Action Secrets.

I created secrets at the Github Organization level so I followed the steps below to keep my OSSRH_GPG_SECRET_KEY,OSSRH_GPG_SECRET_KEY_PASSWORD,OSSRH_USERNAME and OSSRH_PASSWORD secret. If not clear by the name these are my GPG Secret Key, my GPG Secret Key password, my OSSRH Username (from the token we generated earlier) and the OSSRH password (from the token we generated earlier).If that screenshot feels out of date you can find the docs here

✅ Secrets configured!

Setting up the Github Action

Now that the Github Action Secrets are available let’s go ahead and configure the Github Action itself. To give credit where credit is due, I created this github action using this gist as a starting point. You can find the Github Action workflow file here.

You’ll see below that this Github Action will run on the latest ubuntu and execute the publish job which has several steps. The steps will setup the maven central repository info, install the secret key and then run the command to publish to OSSRH.

name: Publish package to the Maven Central Repository
on:
  release:
    types: [created]
jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Set up Maven Central Repository
        uses: actions/setup-java@v1
        with:
          java-version: 11
          server-id: ossrh
          server-username: MAVEN_USERNAME
          server-password: MAVEN_PASSWORD
      - id: install-secret-key
        name: Install gpg secret key
        run: |
         cat <(echo -e "$") | gpg --batch --import
         gpg --list-secret-keys --keyid-format LONG
      - id: publish-to-central
        name: Publish to Central Repository
        env:
          MAVEN_USERNAME: $
          MAVEN_PASSWORD: $
        run: |
          mvn \
            --no-transfer-progress \
            --batch-mode \
            -Dgpg.passphrase=$ \
            clean deploy

✅ Github Action ready to go

Running the Github Action - let’s test it with a Snapshot release

Now you’re ready to run the Github Action. I’d recommend testing out the publishing of a snapshot release first. To ensure you do this make sure your version in the pom ends in -SNAPSHOT as discused earlier.

Once the version on your main branch includes -SNAPSHOT go ahead and run the github action workflow. You should see the publish job successed in a few minutes depending on how long your build takes. Ours took 1m 20s the first time.
After the deploy job successfully runs you can head over to https://s01.oss.sonatype.org/content/repositories/snapshots/ and navigate to your project to verify that the snapshot has successfully deployed. It should look something like this:

✅ Snapshot published!

Running the Github Action - now let’s make an actual release

Now that the snapshot has successfully deployed let’s go ahead and make a real release. Make sure your code is ready before doing this part of course :)

Change your version in the pom to remove the -SNAPSHOT, so it should end in a number. Something like 1.1.0.
Re-Run the Github Action workflow. Wait for the publish job to succeed :)

✅ At this point our project will be staged for release. There is just one more step!

Approve the Deployment in Nexus

Now that our project is staged for release we need to login to the OSSRH Nexus Repository Manager to promote the release.

Login to the OSSRH Sonatype Nexus Repository Manager
Navigate to the Staging Repositories in the menu on the left hand side.
Examine the contents of the release and if everything looks good close the release. More information is available here
The OSSRH deployment is now complete, but if this is your first release remember to go back and comment on your “New Project Ticket” we created earlier so your project will sync to Maven Central.

✅ Deployment Complete!

Check out the deployed project!

After ~24 hours head over to Maven Central’s search and you should be able to find our project by typing in your groupId or artifactId.

Conclusion

Hope this was useful! Feel free to leave a comment if you have any questions :)

Reflecting on my First Hackathon

2021-03-19

The Hackathon: MakeUofT

This past weekend I attended my first hackathon (well a make-a-thon in this case) as a sponsor and mentor since starting my role as a Developer Advocate. I have to admit that going in I had pretty low expectations. I was traveling from Orlando, FL to Toronto, Ontario on a holiday weekend to what I thought would be a pretty boring booth duty gig, and then to judge some projects that after only 24 hours of work would be half thought out and maybe partially working, if at all.

Well, the weekend has come and gone and wow was I wrong. MakeUofT not only surprised me, but it absolutely blew my mind and reminded me how far technology has come in the past decade. All while being a blast to participate in. According to their website, MakeUofT, at the University of Toronto, is Canada’s Largest Makeathon and is a Major League Hacking member event. It brought together teams of students from across North America for a weekend of hacking and creativity. And not just software hacking, the event had a wide variety of hardware available for participants to use which ranged from Raspberry PIs to Qualcomm Dragonboards, sensors, cameras, 3D printers and more.

My Reflection

So why was I so surprised? As a software engineer for the past decade I knew in my mind that we have had many technological advances, but I think it’s natural to see and assess them one by one as they happen. Raspberry PI became a thing, the cloud became the way to go, software as a service became the new norm, etc. And I started to research and use subsets of each of the advances one at a time as my projects called for it, e.g: at my previous company my team replaced physical racks of servers with AWS, used the Atlassian SaaS ecosystem to manage and track the software development process and went from installing & configuring proven software, such as the Elastic Stack and MongoDB to using their SaaS offerings. However, seeing how quickly the hackathon teams were able to go from idea to architecture to mostly working proof of concepts made me step back and really see all the technological advances as a whole. What many teams accomplished would have been nearly impossible just 10 short years ago.

Of course it helps that the students were super tech savvy. With most of them probably being born after the dot-com bubble in the late 1990s they likely never knew a time without computers and it showed. All of the teams that I helped mentor were really sharp: they knew their way around their IDEs and code in general, were able to quickly pick up on new technical concepts, slap together some code and see it run. On top of the extra tech savviness, the advancements that I mentioned above are the baseline for them. They expect to be able to just sign up for a service like Solace PubSub+, have it “just running”, and use it to stream events immediately; whereas my first experience with that same Solace technology about ~9 years ago was to navigate the website, contact the sales team, have some meetings to determine feasibility, have hardware shipped, rack and stack the hardware, cable it up and get it added to the network, configure security & access control, and probably some other steps I’m forgetting about before I could even get around to using it. What took me probably a few weeks at an absolute minimum now takes them 5 minutes!

And why was my mind blown? The projects were amazing. Way better than I expected. And in many cases they actually worked 🤯!? Not just the software, but the hardware as well. The students really took advantage of the speed of technology in 2020. They knew that they could develop their proof of concepts quickly so they took their time at the beginning of the event to create well thought out ideas and a feasible architecture instead of just diving into the implementation. A large percentage of the teams even started to think about a potential business plan for where they could take their ideas beyond the event itself! At the end of the 24 straight hours of hacking (yes, very few of the students took time out to sleep) teams set up their projects in the main auditorium where they hosted science fair style demonstrations and judges, mentors and participants got to go around and see what the teams came up with. Seeing the demos was an absolute blast and there was definitely excitement in the air as you looked around and saw everything from drones and rovers to robotic arms and intelligent trash receptacles. If you want to check out some of the projects you can find them on DevPost here which I’ve also shown an image of below.

The Business Value of a Hackathon

At the end of the weekend it’s great that I had a good time this weekend, but let’s face it, our companies don’t sponsor events for us to have a good time. So what do companies get out of sponsoring hackathons?

First and foremost we get to support the up and coming developer community while raising awareness at the same time. It was a pleasure to work with these students and see them begin to bring their ideas to life while also helping them learn about event-driven development and using our companies’ product to do so.

This awareness has multiple benefits: It shows students that your company not only exists, but that it cares about the developer community. These types of events attract the best and brightest up and coming students and this is an excellent away to help identify them and hopefully add them to your team. The awareness also gets students using your technology, and hopefully, pending a good experience, they will continue to use your companies’ technology for future projects as well.

Another great reason for companies to sponsor hackathons is to get candid developer feedback. The students participating in these hackathons are there to have fun and learn, but most of them also want to win. This means they have a short period of time to create something really awesome that will help set their project apart. As sponsors they are going to use your companies’ technology and they expect it to work. They expect to get started fast and be able to use it to accomplish what you told them it is meant to achieve. They aren’t just going to take a look at some sample code, walk through a tutorial and nod their head. They’re going to really dig into the code, pull pieces out and use it to create their project. If there is confusion or speed bumps in your getting started experience they’ll find it!

For this reason alone I would highly recommend any Developer Advocate or for that matter anyone who “owns” an API get your company to sponsor a hackathon. On this note, don’t be afraid to ask for feedback. When going around to judge the “Best use of Solace PubSub+” prize I asked each team that used our technology about their experience. Was it enjoyable? Would they use it again? Did they have any pain points? It’s not everyday that you get a chance to collect this much feedback in person so don’t pass it up!

After such a great weekend I’m definitely looking forward to the next time I’ll get to participate in a hackathon! Thank you to the University of Toronto IEEE and Major League Hacking for putting on MakeUofT, as well as to the sponsors that made it possible: Solace, Telus, Qualcomm and Huawei, among others. And last, but definitely not least, thank you to the students for coming out with such great energy and dedication.

MakeUofT Developer Workshop & Hackathon

2021-03-19

My First Hackathon

Hackathon - MakeUofT 2020
Co-Speaker - Vats Vanamamalai - Solutions Architect @ Solace
Location - University of Toronto
Audience Size - ~15 at the workshop; ~300 at the event w/ 12 teams of 4 students submitting for the Solace prize!
What happened!? - Vats and I put on a developer workshop where we showed attendees how they can use Solace to stream sensor data from both physical and virtual sensors on a Raspberry PI into Solace Cloud. Once in Solace Cloud we used NodeRed to subscribe to the event streams and visualize the sensor data. This demo was also used throughout the hackathon to explain how PubSub+ can be used to stream event data. Want to check out the demo? See the github url below.
Github repo - https://github.com/SolaceLabs/makeuoft-hackathon

Talk at AWS Re-Invent 2019

2021-03-19

AWS Re-Invent 2019

Talk Title - “Go Event-Driven with Event Mesh & AWS Lambda”
Conference - AWS Re-Invent 2019
Location - Aria, Las Vegas, NV
Audience Size - 60
Talk Recording - Available on Youtube
Abstract - We live in an event-driven world. Events are becoming a core component of new business architectures, and they allow organizations to react in real time to an ever-changing environment. But shifting to an event-driven architecture is daunting—how do you move events from on-premises data centers to the cloud? How do you transmit events across AWS Regions? How do you enable legacy applications to communicate with modern, cloud-native applications built on services such as AWS Lambda and Amazon Kinesis? In this talk, we discuss how an Event Mesh enables organizations to meet these challenges. This presentation is brought to you by Solace Corporation, an APN Partner.

Solace NY User Group 2019

2021-03-19

SpringOne Platform 2019

Talk Title - “Solace Event Portal Demo”
Conference - Solace NY User Group 2019
Location - Millenium Partners, New York, NY
Audience Size - ~80
Abstract - I had the pleasure of demonstrating the brand new Solace Event Portal to an audience of current and prospective customers. The demo included showing current functionality as well as showing some of what will be coming in the future :)

Developer Workshop at SpringOne Platform 2019

2021-03-19

SpringOne Platform 2019

Talk Title - “Be Event-Driven with AsyncAPI & Spring Cloud Streams”
Conference - SpringOne Platform 2019
Co-Speaker - Jonathan Schabowsky - Senior Architect, Office of the CTO @ Solace
Location - Austin Convention Center
Audience Size - 60
Codelab - https://www.marcd.dev/s1p-codelab-2019
Code Repository - https://github.com/Mrc0113/workshop-scs-s1p

Workshop Description:

Are you passionate about building modern, distributed, real-time applications? Is your organization adopting an Event Driven Architecture to compete in our event-driven world? AsyncAPI is the industry standard for defining asynchronous APIs. Build and expand your developer toolbox by learning how to create event-driven microservices using Spring Cloud Streams, AsyncAPI and Solace PubSub+. And deploy those microservices using Pivotal’s Cloud Platform to allow for continuous delivery and agility in hybrid and multi-cloud environments.

Solace PubSub+ is an advanced event broker used by some of the largest enterprises in the world to process many billions of messages with low latency and high performance every day. It is available as a run-anywhere software, purpose-built hardware, and a managed service. Connect your Brokers to form your Event Mesh and dynamically route events across hybrid and multi-cloud environments using open standards such as MQTT, AMQP, JMS, REST, and of course our Spring Cloud Streams Binder!

In this hands-on workshop, attendees will be guided through a CodeLab where they will: Discover how Spring Cloud Streams (SCS) enables developers to create highly scalable, event-driven applications. Combine Spring Cloud Streams & AsyncAPI Code Generation to see how easy event-driven development is becoming. Effortlessly deploy those microservices using a PubSub+ Event Mesh and Pivotal’s Cloud Platform to achieve event-driven, multi-cloud nirvana.

Talk at API Days SF 2019

2021-03-19

API Days SF 2019

Talk Title - “API Management, Meet Event Management”
Conference - API Days SF 2019
Co-Speaker - Jonathan Schabowsky - Senior Architect, Office of the CTO @ Solace
Location - Yerba Buena Center for the Arts, SF
Audience Size - 125
Abstract - Event-driven apps and architectures will be transformational to businesses when we have the tools to manage events the way we manage APIs. Documenting, discovering, registering, and co-creating events and applications is key, but it’s not possible today. In this talk we’ll introduce the concept of an “Event Management Platform” that will perform similar functions to an API Management Platform, but for the event-driven world. We’ll also demo code creation for event-driven microservices using AsyncAPI.

Check out the talk on Youtube!

Talk at OrlandoDevs Meetup

2021-03-19

ODevs July Meetup - “Modern App Architectures”

Talk Title - “Building Event-Driven Apps for a Real-Time World”
Conference - Orlando Developers Meetup - July 2019 - “Modern App Architectures”
Meetup Link - https://www.meetup.com/OrlandoDevs/events/262394428/
Location - Tree House @ Full Sail, Orlando, FL
Audience Size - ~90 (We filled up the room!)
Abstract - We live in an event-driven world. Events are a core component of all new business architectures and allow organizations to react in real time to an ever-changing environment. As software architectures shift to more event-driven designs, the usage of traditional REST-over-HTTP for communication can limit the flexibility and performance of distributed applications and microservices. This talk will discuss why this is the case and introduce developers to event-driven design.

My DevRel Journey Begins

2021-03-19

A Public Speaking Success

This was a really exciting (and nerve-racking) week for me. Upon taking my new position at Solace as a Developer Advocate earlier this year I officially joined the Developer Relations community. I knew that this meant I would eventually have to face my fear of public speaking and overcome it. I am proud to say that this week I made a large step towards doing just that. I figured I’d write a quick post on about my week and touch on a few tips that helped me when speaking this week!

The first half of this week was quite hectic for me. I flew to Chicago on Sunday evening for a Developer Workshop with one of our customers on Monday. Then caught a flight Monday evening to San Francisco for MuleSoft Connect on Tuesday & Wednesday. At MuleSoft Connect I did the first conference talk of my career before catching a redeye flight home to Orlando after the conference.

A huge thanks to my friend and colleague, Jonathan Schabowsky @jschabowsky, as this week would have been much more challenging without your help! Jonathan kicked off the all day workshop with a presentation before handing it off to me for the hands on portion. The hands on portion of the workshop was a Google CodeLab that teaches the fundamentals of Spring Cloud Streams (you’ll probably see more on this in a future blog). I was a bit nervous going into the workshop knowing that I would literally be in front of the attendees for 3-5 hours, but I found comfort in the fact that I created the CodeLab materials and was more familiar with them than anyone else. Three key tips here!

Tip #1 - If possible, co-speaking with someone you trust for your first talk or two really takes the pressure off. For me speaking with Jonathan really allowed me to relax as I knew if I were to slip up or forget something that he would chime in to provide clarification.
Tip #2 - Create your own materials! I’ve been in countless meetings where I’ve had to present powerpoint slides that were created by someone else and I always have those few moments where I change the slide, there are no notes available, and it isn’t clear to me what point the creator was trying to make with the slide. If you’re going to be talking in front of a live audience I HIGHLY RECOMMEND creating your own presentation material.
Tip #3 - It’s okay to pause and think. Most people, including myself, get the urge to speak faster when presenting to a group of people and feel like we have to continually talk. However, this is not the case! It’s okay for there to be short silences between sentences or slides while you think about what you’re going to say next. It also gives the audience an opportunity to take in any diagrams or graphics being displayed.

After arriving in San Francisco after the Developer Workshop my mind had shifted to MuleSoft Connect. It was a two day conference with my speaking slot being on the second day. During the first day I was able to watch a few of the other speakers do their presentations and get a feel for the conference and it’s attendees while talking to folks that came by our booth (Solace was a sponsor). The next morning I met with my co-speaker, Jonathan, to practice and remove some content from our talk. We originally thought we had a 30 minute slot but found out we were only allotted 15 minutes after arriving at the conference. Because of the time adjustment we did a few dry runs at a nearby cafe and timed ourselves to make sure we didn’t have too much content. A few hours later was show time! We were quite surprised when the chairs in the room were already filled up ~5-10 minutes before the talk. We even ran out of standing room by the time the talk started and we were told afterwards that 40-50 people had to be turned away due to the room’s capacity! Once again Jonathan kicked off the talk for the first ~5 minutes and did an introduction before handing it off to me for the last ~10 minutes where I got to show off a preview of our new product that is debuting in the fall. The talk flew bye and we were lucky enough to get a lot of positive feedback throughout the rest of the day after the talk. Here are a few more tips from my experience at MuleSoft Connect:

Tip #4 - Practice your talk! Go through your slides or presentation materials several times prior to the actual talk. If using something like powerpoint, use presentation view if possible and add keypoints that you want to make on each slide. And don’t forget to time yourself! You have an allotted time and don’t want someone forcing you to end early.
Tip #5 - Accept that you don’t have to know everything. You also don’t have to be the smartest person in the room to present. I’m definitely not. One of my worries before doing public speaking engagements was that people in the audience would know more than me about my subject or try to stump me in the Q&A session by asking a super detailed question. But that isn’t the case. Most audience members will respect you just for going on stage and speaking. They know it’s not easy and aren’t there to badger you or cause issues. As said by Heraclitus - “The Only Thing That Is Constant Is Change.” This is especially true in the tech field where things are changing every day. You could learn something in detail 365 days a year and still not know nearly everything there is to know in the tech field. You definitely know things that many of your audience members don’t and vice versa.
Tip #6 - Skip the Q&A session. If you’re not comfortable taking questions on the stage just use all the time during your talk and end with something like “Thank you all for attending - If you have any comments or questions I’d love to hear from you and will hang around after the talk”
Tip #7 - Duration - Start Short. As the room started to fill up and then went to standing room only I definitely started to get more and more nervous. I was able to calm my nerves and take solace in the fact that I only had to speak for 10 out of the 15 minutes and that I had more than enough material to do so (which I knew from tip #4). For your first few talks I would definitely suggest submitting talks for some of the shorter slots.

I’m still a long way from considering myself a ~~good~~calm public speaker, but this week was a huge first step towards eventually being one! I hope the tips I shared above can also be useful to you as well. Definitely let me know your tips in the comments :)

Talk at MuleSoft Connect 2019

2021-03-19

My First Conference Talk was a success!

Talk Title - “API Management, Meet Event Management”
Conference - MuleSoft Connect 2019
Co-Speaker - Jonathan Schabowsky - Senior Architect, Office of the CTO @ Solace
Location - Marriot Marquis, San Francisco, CA
Audience Size - ~100 (with ~40-50 turned away due to room capacity!)
Abstract - Event-driven apps and architectures will be transformational to businesses when we have the tools to manage events the way we manage APIs. Documenting, discovering, registering, and co-creating events and applications is key, but it’s not possible today. In this talk we’ll introduce the concept of an “Event Management Platform” that will perform similar functions to an API Management Platform, but for the event-driven world. We’ll also demo code creation for event-driven microservices using AsyncAPI.

marcd.dev

Publishing Github Java Packages to Maven Central for a New Domain

Overview

Setting up OSSRH (The Repository)

Get An Account

Prove Domain Ownership

Create Your User Token

Configuring the Maven pom

Create GPG Keys

Create Your Key

Share Your Public Key

Configure the Github Secrets

Setting up the Github Action

Running the Github Action - let’s test it with a Snapshot release

Running the Github Action - now let’s make an actual release

Approve the Deployment in Nexus

Check out the deployed project!

Conclusion

Reflecting on my First Hackathon

The Hackathon: MakeUofT

My Reflection

The Business Value of a Hackathon

MakeUofT Developer Workshop & Hackathon

My First Hackathon

Talk at AWS Re-Invent 2019

AWS Re-Invent 2019

Solace NY User Group 2019

SpringOne Platform 2019

Developer Workshop at SpringOne Platform 2019

SpringOne Platform 2019

Workshop Description:

Talk at API Days SF 2019

API Days SF 2019

Check out the talk on Youtube!

Talk at OrlandoDevs Meetup

ODevs July Meetup - “Modern App Architectures”

My DevRel Journey Begins

A Public Speaking Success

Talk at MuleSoft Connect 2019

My First Conference Talk was a success!