Saturday, June 7, 2014


More to come. I have recently changed all of my old blogs to something more permanent and something I don't have to pay for.

A little about me: I joined the U.S. Marines right after high school, I have been a Project Manager at Apple, Software projects for large companies such as IBM and worked my way to being a Software Architect at several companies in healthcare, automotive repair and defense industries. I enjoy helping to mentor other developers, update upper management on the state of things and been a key developer on critical flagship million dollar products. My experiences have also had me lead software development teams in Vietnam, Uruguay and Sir Lanka.

I have a B.S. in Computer Science from Neumont and I'm a candidate graduate for my M.S. in Cybersecurity with specializations in Cyber Operations and Computer Forensics. I will begin teaching Cybersecurity from High School to College/Universities to give back to the community and when needed, I help an organization named Operation Underground Railroad to help save children being trafficked in international countries and yes, this affects the United States and should be your concern as well.

I will attempt to take all my experience and knowledge and viewpoints to help my readers learn what I have learned, follow through on my personal projects and journey with me in my career change from Software Development to Reverse Engineering and Cybersecurity.

This will be accomplished by detailed step by step walk through of technical research. My philosophical views of the current workforce environment and building foundation knowledge upon complex subjects.

I hope you enjoy learning as much as I do and I hope to become a passive mentor to those that read my blog posts.

I will begin by posting  some of my previous and linked solutions from my old blog and then continue from there.

Thanks for visiting.

Saturday, February 9, 2013

Why creating a engineering wiki site. (Living Document) is a good thing.

Recently I’ve started at company that didn’t really have a good solid engineering wiki. Let me state the problems and if you fall in this category, you might want to start thinking about looking at your software development practices.


  • Knowledge Islands: Anytime and I mean anytime you need answers about something everybody always directs you to somebody else. The alternative is to spend so much time in code that might be so abstracted or not very transparent that although you CAN figure it out, the cost to the company is high. OR It’s pretty much impossible for said individual to move on to another project without constantly being bothered about his “design” six months after he’s left. When I say bothered I mean weekly.
  • Knowledge Gaps: Do you have multiple efficient teams but all all of them don’t contribute to the over all “Engine” so that the car all moves in the same direction?
  • Very unclear/no requirements: Agile does not mean you do NO documentation.
  • Each standup/scrum master does their own thing: On this team you create tasks for unit tests and then you swap to another scrum master and unit tests are atomic and “should” be included in as apart of your tasks already.
  • Engine that could: Do you have

Plenty more to add, but you get the idea I think.

Purpose of a Wiki

Some of the benefits of a wiki can be:

  • QA can learn how functions changed or work from previous versions.
  • PM's can disseminate information to peers, which allows feedback and question to better the existing design.
  • PM's can build Releases Notes can be used to communicate outside of engineering about how features work.
  • PM's can share with the entire company about their notes on competition, this helps share the knowledge of understanding to all in engineering to help employees understand the market we fight to dominate.
  • Managers can use use simple and precise language and general propositions in new or existing processes, or evolve them to fit the reality situation.
  • Managers can update status reports for their team, not handled in a TFS Query.
  • Developers can reduces the knowledge islands which can can then allow people to move on to the new projects or not leave a knowledge gap.
  • Developers to write a very high level outline functional and technical specifications (one page) of a Feature and can do so right after development has taken place. (Not before and not months after..)
  • TAMS can build install guides which can be used inside/outside their existing team.
  • New employees are empowered to find answers on their own, or become educated enough to ask solid questions.

..... Just to name a few advantages.

Q: Isn't having a wiki kinda anti-agile?

  • Document writing is not anti-agile. Fostering open communication and getting feedback from others/customers is a important aspect of being agile. it's more efficient and it allows documentation to evolve from its original to a current working state as well as disseminate that information across the company.

Okay.. so I’ve convinced you to start a wiki for your engineering company. Here are some problems you will want to consider solving.

  • If emails are sent out and they link a wiki page. What if that wiki page is changed. Portal sites like Sharepoint have static URLS so you if the page changes, the email link becomes invalid.
  • Code Syntax Highlighting, it really helps.
  • Flexibility
  • Ease of Use
  • Can it hook into your Active Directory?
  • Does it have a good search?

My recommendation for all this: MediaWiki

Here are some tips for your wiki.

  • Prefix all your pages with something like: We call it a “Manual of Style’
    • Design - 
      • (Code is the comment my butt), This page doesn’t capture the design the developer was “going” for. Or the “right” way they intended you to add to their design.
    • Tutorial -
      • How To, this lists step by step how to do something
    • Guide -
      • Best practices
    • Standard -
      • This is a YOU MUST follow this.
    • Process -
      • This is a stream line process. Not something to be blocked on. But it outlines easily what’s expected.  Do this, email this email group. here’s a template that details what we want to capture.
    • ….. etc etc
  • Your SDLC (Software Development Lifecycle) should be focused on delivering business value with emphasis on high quality frequent releases. It should be based on the following four values:
    • Over communication
    • Empowering Teams
    • Continuous Iteration
    • Delivering Customer value early
  • Build a Category system that fits your company. In my current company we have “many” products that “share” components. So I built categories that are “Features – “ Then everybody binds their page to those Features and all those Feature categories are bound to each Product that uses them. That way if they are shared they can be found easily. It also easily shows a Feature list for each product.
  • Build a wiki syntax help page that details how to create a new page, or how to bind to the categories. etc.
  • Build a email group of wikihelp and add in as many good solid stakeholders. So when question is asked, all get it and understand the solution. i.e. form a committee
  • Organize your companies SDLC and Processes, show in there what’s expected from engineering (QA, Installers, Build, Devs, PMs, Mgr) on a Daily, Weekly, Sprint, Release. This way it’s clear and understood by all.


  • Getting a company, it’s employees to switch gears and adopt this culture changing event is going to take time, you need to be active, leadership must adopt this and help enforce and promote it. Eventually it will take as time goes by and people will be able to see the benefits of being able to search for their own answers and understanding clearly what’s going on in the company and what’s expected of them.

Friday, November 9, 2012

Writing more effective emails in your company.

I work at a very email-centric environment and worked under the best CTO I’ve ever had the pleasure to work under. One of his emails he sent out is a great template to follow when writing emails. I wanted to share the email template.

1. Format email responses that consistently repeat the following:

  • What is the problem?
  • What are the steps that will be taken to identify the fix?
  • Who owns driving those steps?
  • When will those steps be taken and results published?

2. The above email should be sent daily until the issue is resolved

  • A day in SRS time is a week for another company

The second item is clarity of communication.  When we are sending an email that contains release notes, UAT notes/plans, crisis management steps (i.e. what was mentioned above), etc. we need to make sure we are explaining things in layman terms.  Describe the situation like you would to a family member who doesn’t work at the company.  Someone you care about.  This may sound silly, but it’s not.  Terms engineering uses are not universal and are thus a foreign language to others in the company.  Please communicate briefly, but clearly using words that are more likely to appear in Webster’s dictionary than in the wiki.

Tuesday, October 9, 2012

Reengineering Engineering with a new SDLC, with influences from and Facebook

Our company has made amazing progress over several years and we create some world class products and we had a SDLC (Software Development Lifecycle) that matched.

  • We were in a niche market owning about 95% and we were doing excellent.
  • We acquired three other companies and placed them under an umbrella corporation.
  • We were generating millions in profits after operating expenses.
  • For the past five to six years we’ve had a twenty percent profit every year.
  • We are the true company that will actual go public. Not just talk about it. You see we’ve been keeping our closet clean and our books show that for the past six years we have profits, a clean SDLC, and a top notch workforce, we continually get on the Inc. 5000 as top 5 fastest growing software company.
  • We’ve built up a great culture here. People we hire know how to work hard and we know how to reward that work.

However as the term goes “who moved my cheese” things change. We turned around and had a recession in the automobile industry so we had to adjust. We then had a dozen competitors who were taking our business away from us.


We offered a “Premium” package, this means we offered our customers everything. Put our products in your shop. Follow our processes and you WILL make more revenue which pays off our cost and puts a s**t amount more money into your pocket. Just because somebody builds something that looks like clone at a 3rd of the cost, does not mean it equals our product!!. As they soon found out and came back to us. But still! where’s the faith!.

Anyway we got a new presidente that recognized this and ALA Carted our product. Which I think was genius, we now offer completive rates with many behind the covers that our competitors just can’t match.


Okay so now we want to show these competitors who their dealing with. Lets. We need a new SDLC for the new strategy.  It will be painful and tough to communicate to our offshore teams. A quick look at our old SDLC yielded something like this:

  • Milestone I (Define Features)
  • Milestone II (Specifications)
  • Milestone III (Developer Code Complete)
  • Milestone IV (Quality Assurance Complete)
  • Milestone V ( User Acceptance Testing)
  • General Release

This was built with a vertically integrated, monolithic technology for our onsite client/server architecture (distributed). It served us well and when functionality and reliability were being invented to address the needs of our customers.

Cons of old SDLC:

  • It took QA as much time as it took the developer creating the code. Two weeks for a feature, Two weeks for QA.
  • There is or can be a lot of finger pointing between QA and Development.
  • Development might just code something and throw it over the wall, thus developers were not taking as much ownership over not writing bugs VS allowing somebody to find bugs and then building the cushion for them to fix the bug. This still held up the release date.
  • Technical Debt would bite us sometimes because of the all too quick agile design to produce features.
  • Million of other projects to add to the existing core products to address other roles in the service departments. But not enough developers as well as cost of training new development into the domain.
  • Inaccurate early estimates resulted in missed features and their complete dates.
  • Teams compressing their testing schedules to meet the demands of the hard feature date.
  • Lack of visibility at all stages of the release.
  • Late feedback on features at the end of the release cycle.
  • Long and unpredictable release schedules.
  • Gradual productivity decline as the team grew.


Here is some great resources that helps put things in perspective.


NOTE: I just want to say in video 2. I love how Eric Schmidt started talking about US workforce and how he believes what America needs to accomplish to help bring it back into the top workforce of the world. I think it starts around 0:45:00. It’s very interesting.


Outcome of our Company Engineering Standards Meeting.

  • Foster Open Communication and over communicate.
  • Empower teams.
  • Continuous iteration.
  • Delivering customer value early (More agile type processes in the form of weekly releases).

So what did we do. We looked at how Facebook operates and focus our SDLC towards their structure. Yes we know we are not Facebook. which is why we don’t adopt everything across the board. But obviously they have some good ideas.

  • We eliminated quality assurance and took all those resources with their existing domain knowledge and put it back into the development organization.
  • This means quality is now the responsibility of all developers.
  • We determine to build a software architecture to be more in line with and their service offerings.
  • The development organization will adopt test driven development that allows for the discovery and resolution of bugs at the top of the project effort instead of at the end. “lean manufacturing” or lean software development.
  • The development team has ownership over the features, this means they are responsible for seeing their feature promoted to production in a controlled manner.

Each team is now responsible for their own:

  • Browser/OS Test Matrix.
  • Repository Updates.
  • End-to-End Testing.
  • Environment Update Testing.
  • Crash Emails.
  • IT updates.
  • Load and Performance Tests.
  • Release Version Tracking.
  • Server Setup.
  • TSG (Trouble Shooting Guide) Documentation.
  • User Acceptance Testing, in combination with other teams.

What we learned:

It has now been a 12 months since we’ve completely revamped our engineering SDLC so what have we learned, what’s the the post mortem?

  • We are now a loosely coupled organization (Robust).
  • We built a CI server that allows every team to use Ant and PowerShell to build their own CI that works for them.
  • Every team now implements acceptance tests driven by the ScrumMaster/PM.
  • Every team now has all their Ant/Powershell scripts custom to their unique needs and running on every check.
  • Each team has dropped off branches and we focus on a single main branch.
  • New teams/projects formed pick the new technology. So although we are primarily a Microsoft workshop. We have Java, Rails, Android, I O/S teams. (After approval. of course.)
  • Teams have adopted testing as part of their development processes
  • Reduced the number of processes.
  • Strengthen those processes that remain so they now have more attention.
  • Teams that spent a lot of time manually testing their products, now focus that time allocation towards building a effective acceptance test or integration test when applicable.
  • Don’t write up bugs caught during the development life cycle. that just slows you down. Only create the bugs after a project has passed all unit and acceptance tests when a bug is found.
  • Teams now focus on team throughput rather than individual productivity.
  • Simple agile processes with common vocabulary.
  • Prioritized work for every team.
  • More defined organization roles (ScrumMaster, Product Owner…).
  • Daily metric visibility into each team.
  • Weekly Scrum of Scrums that provides visibility to all teams at a higher level.
  • Reduction of bugs.
  • Potentially release-able products every 30 days.
  • Mandatory design meetings, code reviews. Any change no matter what is reviewed by at least one person
  • Our code is beginning to look like one single developer wrote everything, not just a multitudes of everybody.

What we would do next time:

  • Involve more individual contributors earlier.
  • Train PM earlier.
  • Work on automation earlier.
  • Communicate delayed deadlines to executives due to the reengineering.
  • Be more clear to workforce what the new SDLC rules are and ensure the dev managers enforce them more.
  • Encourage more peer to peer coaching.
  • Create a better dedicated, fully empowered cross functional rollout team.
  • Managers need to understand to be patient and expect mistakes.

I hope this information enlightens you as it has me through this process. Much thanks to my old CTO Marcus Daleyand VP of Software Architecting Nate Zobrist. Marcus is a CTO that can keep at least 600 people all on their toes and pushing them all to be better and everybody should thank him for making them better at their career. Nate is a forward thinker and just has a much higher IQ then most anybody I’ve ever met.

Sunday, September 9, 2012

Hiring Fresh Engineers VS Seasoned Engineers.

Me and friend at my company were having a discussion on this topic, I thought I would share.

Company Problem:

In a leadership position you want to attempt to get a talented, preferably super star team.  To assemble this team, every manager is faced with which pool of developer he/she wants to focus efforts in.

Seems the current trend with some larger companies like Google and Facebook is to hire, isolate from the workforce on a boot camp project for a few months (so employees don’t miss Josh, who was a great guy, but gone in a few months.) and then determine termination or placement into the engineering ladder. So who best to focus efforts on attempting to recruit?

His view as I understand it:

His thoughts was to pick only from the Fresh Engineers pool. Because most likely you’ll get the root skillset that drives the best engineers. Passion. With passion you can provide them a great training ground, and with the different degrees of mentoring and reviews, which can be a big help for them in the first couple of years. As a bonus, they can join at a cheaper salary.

You are less likely to find a Seasoned Engineers who has that same level of passion that’s wanted to make a good employee.

Thus, his choice, hire from fresh engineers, put them in boot camp, determine placement.

My view on this matter:

I think a Fresh Engineer should try to find a company that will truly grow him/her and fill in the gaps of education or self taught programming with experience to build a well rounded and solid engineer. However some students end up at a company and never learned the modern tools they are using. Do you really think that he/she is going to show you what a super-star they are in a few months? I don’t believe so. Most companies must hire a developer coming out of school and pay them their salary for at least a year before their return on investment starts coming back to them. But during this time the criteria of what’s considered a “super star” is set. Each company. I would even say each manager, has a different set of pre-defined criteria’s on what they consider a excellent talent.

for Seasoned Engineers. This is the engineer that you can put on the un-sexy projects, the projects that are a pretty thankless task and there isn’t really any rewards or spotlight, but are very necessary. These engineers are seasoned enough to get the job done and to not put up a big fight about going to these projects. Of course they also want the sexy projects as well, which helps them enjoy their work too. It’s tough to keep a good programmer as many many other companies will snatch up good talent.

My Conclusion

So the way I see it is that you need a mixed team of both. Fresh and Seasoned Engineers. Passion and Dedication to getting the job done. It won’t take long before the team will close the technological knowledge gap and all your engineers are within the same range skillset focused towards the overall team project outputs.

There is so many more differences I can get into between the two types of developers. But it’s not for this article.

Monday, July 9, 2012

Be nice to your fellow developer in a shared environment.


Several times we’ve found the need to hook a debugger from Visual Studio into the deployed central server dll code, to see what’s going on.
However on our shared environment we have several instances of IIS (W3WP.exe) for each instance running. So which one is the one we are supposed to hook into.  If you hook into all the processes you might get a break point from somebody else testing at the same time. So here’s a little trick to find your correct IIS process running to hook your debugger into.

From IIS 7.0 you need you to run IIS Command Tool ( appcmd ).
• Start > Run > Cmd
• Go To Windows > System32 > Inetsrv
• Run “appcmd list wp