“Software Architect – How to Be More than a Title and a Visio” Takeaways

On 6/14/2018 at the Houston Dot Net User Group monthly meeting, I had the privilege to attend Devlin Liles’ presentation on “Architect – How to be more than a title and a Visio”.  The video of that presentation will be made available on the HDNUG YouTube Channel, and my takeaways from that session can be found below.
In the realm of architecture, there are a few different stages of evolutionary awareness that companies and architects mature through.

Stage 1: Technical Design
  • This is the first step beyond “I need to get it working”
  • At this stage, you should be using practices like Test Driven Development (TDD) to enable good design
Stage 2: Solution Design
  •    Solve a problem, and to solve a problem you have to understand the problem
  •    Question your own design decisions
  •    Design is wrong if it doesn’t respond well to change
  •    Design is wrong if things that should be simple are really hard
  •    Trick: Make as few decisions as possible
  •    Soft skills not technical skills are more important at this level
  •    Be able to listen to different opinions and parse out what matters
Stage 3: System Design
Stage 4:  Enterprise Application Architecture
  •     These are the 5 – 7 year projects that are highly complex and tied to large revenue opportunities
  •     Requires a different set of patterns: domain logic patterns, data source architecture pattern, ORM, distribution patterns,
  •     Have a goal of long term interoperability;  prevent the need for rewrites
  •     Focus on emerging tech and prepare (e.g. in order to prepare for ML, start building a massive storehouse of data)
  •     Need to know the implications and the systems that will come out of a choice and be able to capture the benefit and risk to the P&L
  •     Promote consistency and avoid remaking decisions
  •     Most importantly, do not endanger the business
Posted in Software Architecture | Leave a comment

SOA Anti-Patterns and Solutions

I turned up this gem while looking for a list of common SOA anti-patterns: http://www.oracle.com/technetwork/topics/entarch/oea-soa-antipatterns-133388.pdf.

I appreciate the focus on needing to solve the organizational challenge around SOA as well as the technical challenges.  I’ve recapped the anti-patterns and the proposed solutions that I took away from the article below:

  • From Application Silos to SOA Silos Anti-Pattern – Solution: Establish a center of excellence or an architectural review board that will ensure communication and interaction across teams.
  • Build It and They Will Come – Solution: Establish an architecture review board that will clearly define the architectural roles and communication responsibilities for the various layers of IT execution and relevant artifacts.
  • Over-Engineer Reference Architectures – Solution: Architectures should evolve along with business requirements. Adopt a just-enough, just-in-time architecture that reflects business requirements and available IT resources.
  • Undefined Baseline for Business ROI – Solution: Plan and budget projects with value-based milestones, and include the right contingencies – including asking for help from outside experts.
  • Web Service Sprawl – Solution: Be deliberate about the creation of enterprise services and govern the design of your service contracts.
  • Armchair Architecture from the Ivory Tower – Solution: Always provide usable reference architectures. Be clear about their capabilities and limitations and how they should be used.  Validate your architecture rigorously.
  • Scattered SOA Strategy Entangled with IT Strategy – Solution: Get and set expectations with absolute clarity when adding SOA to a project midstream.
  • Expecting a Free Ride on the SOA Train – Solution: Embrace a maturity framework, build a shareable enterprise foundation, and invest in enterprise-wide training and adoption.
  • Where’s the Money? Or SOA Equals EAI 2.0 – Solution: SOA is more than an ESB deployment and is not just a matter of using Web services for interfacing between systems.

Many thanks to Peter Heller for writing this article.

Posted in Software Architecture | Leave a comment

Recap from CodeMash 2015

First off, I would like to thank Steve Smith, @ardalis, for encouraging me to go to CodeMash 2015.  Without him, I would have just written off CodeMash as a crazy conference for the locals in Cleveland, where people go to freeze.  But now I know differently.

Here is a list of my takeaways from CodeMash 2015:

  • Man there are a lot of kind, fun, geeky, software engineering and technology enthusiasts in the world.  I am not alone!
  • On day one, I spent half of the day working on creating a mobile friendly Web API for the Humitarian Toolbox project (github.com/htbox).  @billwagner and @tonysurma where there to help me get started, and I appreciated the introduction.  I spent the second half of the day brushing up on my SOLID C# skills creating a little RTS shoot’em up game on Mars.  Many thanks to Nicolas Martin who helped me during this session when I had some questions.  At the end of the day, I got to play Artemis and kick some Rebel butt.  All in all, a fulfilling day.
  • On day two, I spent the entire day with @jenniferMarsman and @davidgiard learning how to create games for many different platforms using Construct.  I actually got so far as to create two levels of a game that I have high hopes for releasing to the Windows Phone app store among others.  Given that I have a day job, it will probably be a few months.  I can’t thank @jenniferMarsman enough for all the help and enthusiasm on this topic.  It is the most fun I have ever had at a conference (best session ever).  I got to round out the day by playing some Nuns on the Run (a board game) with some kindred spirits.
  • On day three, I went to session after session with @williamklos getting me fired up about queuing strategies, @garyshort making data science look easy, @careypayette giving an IoT talk that made me want to fly back home to tinker more with my Galileo, and @theSeanOC giving me some great insights on how bit.ly achieves such great up time.  At the end of the day, I got to play a good long game of Caverna with the guys from DNSimple.  Does it get any better?

In summary, I would highly recommend the CodeMash conference. If my recap above sounds interesting to you at all, then I can guarantee you will have a great time, as I have a propensity for understatement. I know for myself that I’ll be back.

Posted in Software Architecture | Leave a comment

Pair Programming vs Solo Programming

I’m in the middle of taking a Engineering SaaS course offered by two great Berkeley professors (Armando Fox and Dave Patterson), and one of the core concepts they are advocating is the benefit of pair programming.

Unfortunately, I’m finding it very difficult to find someone to pair with remotely, even though the technology using Google Hangouts seems to be a great tool for enabling remote pair programming.  In my case, I can only free up pockets of 15 minutes here and there to work on the class exercises, which does not lend itself well to finding a stranger on the web to pair up with and work in those tiny chunks.  Interestingly enough, I am finding that using test driven development while working in 15 minute chunks is working really well, as TDD allows me to easily pick up where I left off with confidence in the quality of code that I’m creating.  Now I will say that I’ve participated in and even facilitated several coding dojos over the past 12 months, and during those sessions we have used pair programming in person, and I’ve found that the technique of switching roles between one writing tests and one coding to pass the tests has been great for pushing the thinking in real time towards developing quality solutions.  Also, the benefits of a second pair of eyes and a second set of experiences while coding also helps sharpen ones skills.  Coding exercises done as a pair definitely has value as a learning experience.

Posted in Software Architecture | Tagged , | Leave a comment

What I learned from Tech Ed 2014 in Houston, TX

Microsoft is evolving, and it feels like they are upping their game of helping developers create great software.  I truly believe there has never been a better time to be a software developer.  Here are some things I learned from the recent Tech Ed held in Houston, TX.

My main take away was regarding Microsoft’s roadmap for ASP.NET. Microsoft’s next version of ASP.NET, ASP.NET vNext, is coming sometime over the next several months and you can watch its evolution on GitHub (https://github.com/aspnet/Home):

  • ASP.NET is going modular, just include what I want from NuGet.
  • ASP.NET is going Open Source
  • Microsoft and Xamarin are partnering to provide a strong mobile cross platform solution
  • .NET config file and package management merging into a new format using json
  • Deployment greatly simplified with runtime and framework deploying with application

Beyond this main takeaway regarding ASP.NET vNext, there were several other observations I had regarding various technologies and practices.

BrowserLink – powerful tool with VS that can aid CSS and HTML debugging on multiple browsers

Biztalk Hybrid connections – a solution to the problem of wanting to keep certain data and services on premise while other data and services are in the public cloud

SOLID deeply embraced by community at Tech Ed.  Chris Klug covered these principles really well in this session: http://channel9.msdn.com/Events/TechEd/NorthAmerica/2014/DEV-B315#fbid=

Angular is gaining major traction as a framework for declaring dynamic views in web-applications.  Nice tools to use with Angular: Hot Towel – good jumpstart, Side waffle – nice template helper, and Breeze – rich data and validation experience on the browser

If you are trying to wrap your mind around Dependency Injection, this will help, as Miguel Castro builds up an example with no DI all the way up to a version with a real world implementation of DI that covers a number of practical edge cases:

Mads Torgersen shined some light on how you can create race conditions by accident when using async in C# along with some great tips and tricks on how to use async correctly.  I particularly liked his coverage of when to use Parralel.ForEach (for CPU bound tasks) vs Async/Await  (for I/O bound tasks):

Rowan Miller introduced me to a mocking framework for EF6: EntityFramework.Testing.Moq

Found out that EF7 will be a massive rewrite of a 15 year old code base and was happy to hear that it will include optimizations for low memory and for NoSQL databases.

Enjoyed a bunch of web app performance optimization tips from Mads Kristensen (note: I’d heard a lot of these a year earlier from Altaf Mehmood, so props to Altaf):

A here is a nice checklist from Mads for making sure your web page is up to scratch:

Posted in Software Architecture | Tagged , , , , | Leave a comment

Getting Used to GitHub

Well, I’m taking a course on SaaS from edx.org and they want you to use GitHub as your source repository for the class exercises.  This has gotten me neck deep into using Git, and I’m now a fan.  For those of you who haven’t gotten into Git yet, I would pass along these few pieces of advice:

1) Use the command line client for Git.  It will definitely help you understand better what Git is and is not doing for you.

2) Go through the Git training hosted on this site: http://gitimmersion.com/lab_01.html

3) If you have experience with TFS, don’t try to map your TFS experience onto Git, as it will trip you up.  Just embrace Git for its own unique approach to source control.

Finally, if you want to follow one of my projects that I’m hosting in Git, go to: https://github.com/cvanhoose/NuGetPAWS.  Just be warned that this project won’t see any action until I wrap up my classes that I’m taking on the side, which should be around July.

Posted in Software Architecture | Tagged , | Leave a comment

Beautiful Software

I ran into this quote that reminded me that software development is indeed a craft. I love when software can be described as beautiful.

“Ugly programs are like ugly suspension bridges: they’re much more liable to collapse than pretty ones, because the way humans (especially engineer-humans) perceive beauty is intimately related to our ability to process and understand complexity. A language that makes it hard to write elegant code makes it hard to write good code.”

– Eric S. Raymond

Posted in Software Architecture | Tagged , | Leave a comment

CTLS 2014 Spring Hackathon

In March 2014, I hosted an internal Hackathon event at CT Lien Solutions.  22 technologist participated by forming 9 competitive teams that dedicated two 12 hour days to developing a working software solution to a CT Lien Solutions’ business problem.  Entries were evaluated on technical innovation, technical achievement, and potential value generation.  We had a winning team emerge (Che’ Smith, Chetan Vihite, and Sarah Althoff-Sams), but their winning idea will have to remain a secret on my public blog here.  Sorry guys.  If you happen to work for Wolters Kluwer, you can read more about the event here: internal blog.  Just in summary, I would like to say that the event was a smashing success.

Here are some of my key takeaways:

1) Don’t let worry about Return On Investment deter you from exploring new technologies and how they might apply to your business.

2) If you have time constraints in your daily job that stand in your way of pursuing new technologies, try setting aside a couple days for a Hackathon event.  Think of it as a training event from a time budgeting perspective.

3) A Hackathon is a great tool for improving technical employee engagement, improving development skills, and injecting some innovative technologies into the daily routine long after the official event is over.

4) A Hackathon event should be conducted separately from Innovation Tournaments that are more focused on discovering the right “What” and “Why” to build, and indeed a company’s normal innovation cycle should always be focused primarily on discovering the right “What” and “Why”.  A Hackathon event is more about discovering new “Hows”, and some of those “Hows” might lead to investigating a new “What” and “Why”.

5) If you are in software development, and you are thinking that you would like to do an internal Hackathon event of your own.  Do it!  I cannot over emphasize the positive energy built by one of these events.

Finally, I would like to give a shout out to Paul DeCarlo at Microsoft, Devlin Liles at Improving Enterprises, PluralSight, Telerik, and Xamarin for their participation and support of our event.


Posted in Hackathon | Tagged | Leave a comment

Coding Dojo – Week 6

Our 6th coding dojo was a middle of the day event where we went through the Gilded Rose Kata in C#.  These was a great exercise in working with legacy code, and we were able to build our unit tests, make the required change, validate the unit tests all worked, and then started refactoring code to better use object oriented programming principles.

Our main takeaway was that in the real world when given some code written by folks a long time ago with no unit tests and no documented legacy requirements, we would take some time to determine and document some acceptance requirements around the code we are changing, turn those into some acceptance tests, and then use TDD on our specific changes we are introducing.  We know that we can’t document all requirements or create full acceptance test coverage, but even a little coverage would reduce the risk of a change to legacy code.

For our next dojo, we are going to look at doing a kata that requires F#.

My thanks go out to Susheel, Rajesh, and Glynn for their contributions to the dojo today.

Posted in Software Architecture | Tagged , | Leave a comment

Coding Dojo – Week 5

Our 5th coding dojo was a lonely affair, as the normal crew was either sick, at training, or in meetings with offshore teams.  I took the opportunity to go through Mark Seemann’s Outside-In Test-Driven Development training offered on PluralSight (http://pluralsight.com/training/courses/TableOfContents?courseName=outside-in-tdd).

The concept that you must be able to pull source code from TFS and have the system build and run with no extra setup is one I will take to heart.  He showed how to use the Microsoft.aspnet.webapi.selfhost library to do in-process hosting of his web api allowing for unit testing without any external setup/teardown.  He pointed out that if you have problems figuring out where to start with your unit tests, start with an end state assertion and then work backwards.  Finally, I followed his example of creating a walking skeleton, which is an implantation of the thinnest possible slice of real functionality that we can automatically build, deploy, and test end-to-end.




Posted in Software Architecture | Tagged , | Leave a comment