Review: Codemash v2.0.1.9

Codemash is awesome every year with friends and fantastic sessions and 2019 didn't disappoint.

Around this time every year, developers flock to Sandusky, OH, for Codemash to learn about the latest trends and techniques for development.

There were people from all across the U.S. and even some from London and Brazil (Did I miss a country? Sound off in the comments below!)

Of course, I've already given the reasons to go to Codemash so I won't cover them again.

But it's just such a great time to catch up with various friends you've worked with over the years.

Conference Theme

This year, Codemash had a retro theme for the conference. It's a good thing I grabbed my Commodore 64 shirt before I left.

The main stage was even made to look like a Tandy computer.

Along the stage, a computer museum was created to show the history of how far we've come with technology. I even contributed an old Star NX-1000 printer to the cause (it's to the left of the Toshiba laptop)

Yep, it's a pretty old printer.

But let's get to the sessions, shall we?

Tuesday January 8, 2019

API with Best Practices for Robust API development in ASP.NET Core, Part 1 & 2

Presenter: Kevin Grossnicklaus / kvgros@architectnow.net / @kvgros / Github

Building APIs are the way of the future and APIs are becoming almost as detailed and extensive as web apps themselves.

Kevin started explaining all of the tools required for APIs and was very knowledgeable with everything attached to it. Instead of building APIs from scratch every time, he has a number of NuGet packages to use in APIs to make your life easier.

While I did like everything he touched on to make it a complete API (and I do mean complete), this workshop wasn't much of a hands-on as much as it was a walkthrough of code and how to setup an API from beginning to end.

He explained configuration, using common NuGet packages (so you don't have to reinvent the wheel), documenting your API using Redoc, and how to add Health Checks to your API.

That was in the AM.

In the afternoon, Part 2 was about versioning, global filtering, caching, and mapping your data.

Overall, I liked the workshops, but wanted a little more hands-on during each four-hour workshop as opposed to explaining how the code was implemented.

Wednesday January 9, 2019

AM - Up and Running Quickly with Vue.Js

Presenter: Burton Smith / burton@breakstuff.io / @stuffbreaker

Since a new project started up at work, Vue.Js was one of the components requested to complete the project.

So I decided to dig into Vue a little more with this session.

Burton setup a project using Vue Core, Vue-Router, and Vuex.

The hands-on part of this workshop introduced a web application called Shame Shopping. The web application included merely a title.

Our job was to create a table based on the model and implement data binding and templating into the table.

I enjoyed the session and learned a good deal about Vue.Js. Burton definitely got me interested in learning more about Vue.

PM - Avoiding Landmines – A Tech Leader’s Guide for the Critical Decisions

Presenter: Jared Faris (@jaredthenerd) & Scott Drake (@tscottdrake) / slideshare.net

Jared and Scott gave a fantastic presentation. The key concepts touched upon in this session were:

• Decision Making and Problem Solving
• People and Culture (how do you motivate people, what are their values, etc.)
  
• Quality
• Wrapping up

All of these categories each had an elaborate discussion behind them. Check out the 267 slides in the deck.

This soft-skill session was personally fulfilling to me since I've been in a leadership role recently.

Thursday January 10, 2019

8:00a - What are Observables and why should I care?

Randall Koutnik / @rkoutnik / works at Slack / Slides (pdf)

Since observables are the thing lately and I've seen my share of them in various JavaScript frameworks, I thought this would be a great session on learning a little bit more about them.

Randall presented some code examples explaining Observables using a library called Reactive Extensions (RxJs). These reactive extensions are also for .NET and other various frameworks and are merely a publish/subscribe (pub/sub) model.

He explained when to use map, tap, flatten, mergeMap, and switchMap with observables.

Two other terms he mentioned was Hot/Cold Observables. If you look at slide 52, this is the start of where Hot and Cold Observables enter the picture.

• Hot
  • A single source broadcasted out to all nodes
  • Constructor -> Map -> Filter out to multiple subscribers 1,2,3
• Cold
  • Multiple sources
    • Constructor -> Map -> Filter -> Subscribe
    • Constructor -> Map -> Filter -> Subscribe
    • Constructor -> Map -> Filter -> Subscribe

9:15a - TypeScript for C# Programmers

Presenter: Jesse Liberty / @jesseliberty / http://jesseliberty.me / slide deck

Of course, along with Vue, I wanted to find out more about TypeScript and what better way to learn it than from a C# perspective.

This was a beginner/intermediate session discussing why TypeScript is becoming so widely used.

It's a static-typed language on top of JavaScript. Written using TypeScript, but transpiled down to JavaScript.

Jesse mentioned a tool you can use to view the resulting JavaScript from a TypeScript view: The TypeScript Playground. Enter TypeScript on the left side and see the resulting JavaScript on the right side.

He also went through all of the data types for TypeScript, using super for inheritance, made the audience aware of interfaces, arrow functions, and function overloading.

Very informative and entertaining.

10:30 - Hold Up, Wait a minute, Let me put some Async in it

Presenter: Matthew Jones / @ExceptionFound / http://exceptionnotfound.net / Github project

This was probably the best session at Codemash this year.

Matt brought the technology along with humor during his session.

He had just enough slides to explain async and what he was going to do, but his session was to convert a regular ASP.NET MVC application to an asynchronous application in less than an hour...with audience participation.

He mentioned to never return voids from asynchronous methods, async != multithreading, it does NOT make code faster (but improves throughput), and how it's best to refactor from the bottom-up.

Definitely a solid session...oh, and he got it converted in about 40 minutes.

11:45a - Webpack Encore: Webpack your App and Love it!

Presenter: Ryan Weaver / @weaverryan / http://symfonycasts.com

Ryan covered a product called Webpack Encore which wraps Webpack making it easier to use and provides bundles and default packages to use with Webpack.

So instead of downloading all of the SCSS, Babel, and any other separate service, download what you need from Webpack Encore and you are off and running.

Definitely informative and will be checking that out as well.

1:00p - Learning the Three Types of Microservices

Presenter: Mike Amundsen / @mamound

Mike's session started out slow, but stated digging in about half-way through to define in his own terms what a microservice was: 

A microservices are loosley-coupled components running in an engineered system.

He also about the three microservice types:

• Stateless
  • Simple processors (converters, translators, etc)
  • No dependence on other microservices
  • No local data storage (disk I/O)
  • Most common MSC, but least useful
  • No Shared State
  • Easy to replace
  • Easy to scale up
• Persistent
  • Simple (local) storage (reads and/or writes)
  • Disk I/O dependent
  • Possibly VM or one-U dependent
  • Commonly needed MSC, but not easiest to implement
  • System of Record/Source of truth
  • Relatively easy to scale for reads (CQRS)
  • No cross-service two-phase commits (Saga pattern)
• Aggregators
  • Depends on other ("distant") microservices
  • Network dependent
  • Usually Disk I/O dependence
  • most often needed; most challenging, too.
  • Sequence vs. Parallel calls
  • Timing is everything
  • easy to scale (should be...)

Once those were defined, he explained Nygard's Stability Patterns.

• Stability Patterns
  • Timeout
    • Simple mechanism allowing you to stop waiting for an answer once you think it will not come.
  • Circuit Breaker
    • Way to automatically degrade functionality when the system is under stress.
  • Bulkhead (or Blast Zone)
    • Enforces a principle of damage containment.
  • Steady State
    • System should be able to run indefinitely without human intervention.
    • Avoid fiddling
    • Purge data w/ app logic
    • Limit caching
    • Roll the logs
  • Fail fast
    • If the system can determine in advance that it will fail at an operation, it's always better to fail fast
  • Handshaking
    • All about letting the server protect itself by throttling its own workload.
  • Cache
    • Caching can reduce the load on the server and cut response times to a fraction of what they would be without caching.

Once those were explained, he matched patterns to each microservice and how each pattern could help the microservice.

His session was very informative and complemented the first precompiler session I mentioned above.

Friday January 11, 2019

8:30a - My Users Posted What?

Presenter: Harold Pulcher / @haroldpulcher / pulcher@pulcher.biz / http://bit.ly/cm-presentation / Works at Improving

When I first went into this session, I didn't know what to expect, but since I have a blog and also another project for detecting offensive data, I thought this would be informative to me.

I thought he would've directed people over to Disqus or some other commenting system, but this was a shock to me.

Harold's talk was about the Content Moderator in Azure. This machine-assisted Content Moderation was able to moderator content at scale.

I didn't even know this Content Moderator was available through Azure.

He provided code on how to call it along with the various APIs included with it:

• Review API
• Moderation API
• Content Moderation APIs
• Cognitive APIs

Each one has it's own way of examining content whether it's looking at images, text, or video.

I will probably follow up on this technology as well.

9:45a - Entity Framework (core) debugging using SQL Server: A Detective Story

Presenter: Chris Woodruff / Developer Advocate for JetBrains

I remember this post a while back for his C# advent and it was very informative since others could ask questions regarding debugging and performance.

His tips included:

• Understand Query Plans
  • Check "Include Actual Execution Plan"
• Finding your least performing query
  • select * from sys.dm_exec_query_stats
• Learn about Query Store
• What we can do to improve our EF Queries
  • String Interpolation in Raw SQL Methods
  • Database Scalar Function Mapping
  • Explicitly Compiled Queries
  • DbContext Pooling

Chris didn't disappoint during his presentation and I thoroughly enjoy these types of sessions even though it was a bit "click-baity."

But I still love little nuggets of tips like these.

11:00a - Always be Delivering

Presenter: James Balmert / github slide deck

James' presentation went over the basics of how to implement a Continuous Integration / Continuous Deployment model into your organization.

He defined pipelines, the benefits of pipelines, and gave an origami comparison. Which would you want? Less steps for easier code or a ton of steps for something to go wrong? Smaller changes imply less risk.

James also had avatars for developers, QA, and Tech Ops. As he went through his agenda, he would mention how the developer would feel and would always ask questions.

In the end, everyone had a simple DevOps pipeline to write and deploy code easily.

This session was simply an affirmation of what we're doing at work.

12:15p - Patterns and Architecture: Beyond Microservices

Presenter: Stephen Shary / github slide deck

This was another great session at Codemash. His style of presenting was humorous and informative.

His overview included:

• Define Goals of Microservices
• Code as Documentation
• offload the boiler plate
• Moving to data independence
• Making your data become code

He packed so much into each of his slides, I couldn't do it justice explaining all of it here.

For example, one nugget I enjoyed was when should you NOT use microservices.

• When should you not do Microservices
  • Smaller group: less than 15 people
  • Small data size: less than 100GB of data
  • Lack discipline

Another tip was to use FluentValidations for validating input when receiving a microservice. Well, I guess we know what to use on our business rules.

There were so many of these little tips that it's hard to pack all of them into this post.

I feel everything he presented was spot-on and provided the audience to do more reading when they got the chance on these networking topics.

2:45p - Building a Highly Scalable Service that survived a Super Bowl

Presenter: Keith Elder / @keithelder / http://keithelder.net / Works at Quicken Loans

When I walked into the room and found out it was Erlang-based, I thought I would hear the story about how they got their site optimized for the Super Bowl (He even said, "Did everyone read the abstract and know this talk is about Erlang, right? Ok, quick...lock the doors!")

I'm glad I stuck around.

I remember Keith doing a talk in the past at Codemash and he talked about C#, but this time they decided to use Erlang for their language of choice.

Why?

• It was compiled
• it was dynamic
• it could be distributed and integrated onto other servers while they were running 

For distributed services, this was definitely an interesting monkey-wrench to throw into the mix.

He also explained that their company shuts down for a week (maybe code-freeze?) and they try to innovate during that week and on Friday, they discuss what they accomplished over the week.

He said more companies should introduce innovation into their teams.

Overall, I liked this approach and his story about he could get some sleep at night after implementing Erlang.

4:00p - Get More Miles out of your Legacy App!

Presenter: Brett Whittington / Solution Architect and Senior Consultant

Brett gave an interesting presentation on how to integrate Vue.js into an existing legacy application.

He gave a number of touch points as to where to inject code and suggestions on how to make your legacy application more modern.

Two such suggestions were:

• Convert controllers to Real Web API
• Add Karma/Jasmine UI Testing

Everything was solid and provided clear direction on updating it to become more modern.

Extra Curricular Activities

Along with the sessions, there were game rooms, karaoke, jam sessions, waterparks, and other fantastic events.

I even brought my Disrupt card game with me. It's kind of like Cards Against Humanity but for tech startups. It was a BLAST and our group couldn't stop laughing throughout the night.

Conclusion

This year's Codemash was nothing short of amazing...AGAIN!

If you ever get a chance to head to this outstanding conference, I urge you to head there next year and experience it on-prem.

At least one time.

Also, I HAD to get my annual drink and dessert. This year, it was a white chocolate and raspberry mocha with a Peanut Butter Seduction. mmmmm

I always do it as a last hurrah before I leave every year.

Sooo.....

...see ya next year, ya Hippie!

Did you go this year? What was your favorite session? Let me guess...the waterpark?  Post your comments below and let's discuss!