Jeremy Clark, David Handlos, Arthur Doler, and Erissa Duvall have Sessions on Software Craftsmanship at Nebraska.Code().
Jeremy Clark, David Handlos, Arthur Doler, and Erissa Duvall have Sessions on Software Craftsmanship at Nebraska.Code().
Matthew Watt, David Kerber, Lorenzo Gallegos, and Mitchel Sellers present on Software Craftsmanship at Nebraska.Code().
Jeren Hicks, Tyler Morten, Jerry Nixon, and Caleb Larsen have Sessions on Software Craftsmanship at Nebraska.Code().
Ben Ferguson, Scott Bock, and Brandon Suponchick present on Software Craftsmanship in July at Nebraska.Code().
Adrienne Braganza Tacke presents 'Looks GREAT To Me: Getting Past Bare Minimum Code Reviews' July 24th at Nebraska.Code().
Matt Ruwe presents 'Uncovering Hidden Gems in .NET: Boost Your Development Toolbox' July 25th at Nebraska.Code().
The Case for Software Craftsmanship in the Era of Vibes
https://zed.dev/blog/software-craftsmanship-in-the-era-of-vibes
Scott Bock presents 'Service Observability: An Introduction to Open Telemetry with Grafana and Spring Boot' July 25th at Nebraska.Code().
Brian Zimmer is 'Roadmapping with Critical Thought' July 25th at Nebraska.Code().
Dea Mandery presents 'Points Aren't The Point. Delivering Impact Is.' July 24th at Nebraska.Code().
Caleb Larsen presents 'Object-Oriented Refactoring Strategies and Tactics' July 25th at Nebraska.Code().
Jeren Hicks presents 'Lightning Talks: Sparking Continuous Learning
and a Healthy Culture' July 24th at Nebraska.Code().
Mitchel Sellers presents 'Juggling Hats - Managing the Balance of Life, Family, Technology and More' July 24th at Nebraska.Code().
Matthew Watt presents 'Functional Programming: More than just a coding style' July 24th at Nebraska.Code().
Are you inadvertently making your code more complex than it needs to be? Join Kevlin Henney's workshop 'Keeping it Simple' to explore the real cost of complexity in code, culture, and process. We'll tackle technical debt head-on and discover practical simplification strategies: https://buff.ly/5k4Q7wb #CodeSimplicity #SoftwareCraftsmanship
Technical Excellence: Lost. Like Atlantis. But with more AI JavaScript.
Once upon a time, engineers knew things. Not Googled things. Crafted things. We automated builds, wrote real tests, treated code like it could explode if mishandled, which it did, and we were proud when it didn't. It was elegant. Precise. Shameful if the customer found a bug. Now? It's fashionable to push broken features into production and call it MVP.
Nowadays, we want to engineer. But we don't get the space for applying our knowledge. Every training is useless when you can't apply it.
"Senior Developers" parade around with 10 years of experience by repeating the same year 10 times. They chant Clean Architecture but build everything in main(). They talk about TDD, then mock their way into oblivion. They don’t refactor, as it's not in the ticket. They don’t simplify, they just make it work. They wait for ticket assignments like robots awaiting firmware updates.
Worse: nobody creates anymore. They consume tools. No one understands the layers. No one asks why.
Agility? Without engineering excellence, it's just theatre. You can't move fast if you don't know how your engine works.
Want to be agile? Build engineers who:
* Understand architecture beyond drawing hexagons.
* Write tests that assert behaviour, not just lines executed.
* Know the cost of a dependency.
* Automate not for fun, but for resilience.
* Take responsibility before being told to.
* Stop chasing tools & Start understanding systems.
* Build things that work, not just compile.
Technical excellence is not a luxury. It's the foundation. And without it, you're not building software. You're just decorating the Titanic.
Agility without engineering is chaos in a hoodie.
Ben Ferguson, Scott Bock, and Brandon Suponchick present on Software Craftsmanship in July at Nebraska.Code().
Are you inadvertently making your code more complex than it needs to be? Join Kevlin Henney's workshop 'Keeping it Simple' to explore the real cost of complexity in code, culture, and process. We'll tackle technical debt head-on and discover practical simplification strategies: https://buff.ly/3xrKM6z #CodeSimplicity #SoftwareCraftsmanship
True Engineering Isn't about using tools.
It's in the questions.
Too often, I see "engineering" reduced to assembling frameworks like IKEA furniture, follow the docs, trust the tool, ship it. But real engineering begins where the documentation ends.
Do you know what that smart-syntax language is doing under the hood?
Do you know how your beloved build tool behaves when it comes to automations and generic CI/CD pipelines?
Do you know what your "schema-less" database sacrifices when concurrency climbs?
Do you know how many runtime hacks exist to make your "native" build work seamlessly?
Do you know how your framework manages threads… or fails to?
Many don't. And that's the problem.
We've built castles on sand because the sand came with good tutorials. Engineering isn't about how much you can plug in. It's about how much you understand, especially the parts no one talks about.
If you're not asking, "What isn’t being said?"
You're not engineering. You're just believing and praying.
AI is a perfect example of many people which hype it but don't understand it.
You have incidents, bugs, complexity, legacy and need time for maintenance or migrations? Then you build your system wrong. Technology should help and not hinder us. We need to focus on simplicity, not on overengineering.
Nebraska.Code() ticket sales are now open with Early Bird pricing through 04/18.