Saturday, July 6, 2013

Getting Laid Off

Well, it happened.  Older, wiser engineers than myself told me it is not a matter of "if" but a matter of "when".  And my time finally came--I was one of the folks included in Logitech's round of layoffs last February.

The purpose of this post though is to not analyze my specific situation.  Instead I would like to pass off some things I did to keep my head together and get another job.  What I'm providing below isn't a one-size-fits-all solution.  And really, I'd love feedback if any of this actually helps.  I'm unsure if the ideas below are what got me job offers, or if simply now is a good time to get laid off given how hot the market is.

So without further adieu...

Understand your full time work isn't gone, it simply has changed.

When I got home after being let go, I found that everything necessary to find a new job took just as much time as my old job.  Updating my resume, synchronizing it with linked-in, calling recruiters and contacts for opportunities.  The days after getting laid off were 8-10 hour work days, and these continued until I accepted a job offer shortly after.  I couldn't stop working knowing that the severance clock was counting down.  I went from being a coder to my own sales person and marketer.

Create an Excel sheet.

This is absolutely critical.  My way of problem solving myself out of unemployment was to create sort of a Sales Force style excel sheet to track opportunities.  For each potential company, I had a column for the point of contact (often friends at other companies or the recruiter), the hiring manager (if I made it this far), when to ping them next, and a rating of how good the opportunity is.  The rating of the opportunity was not just based off salary.  I made a scoring system based off of glass door reviews, type of work, commute distance, perceived company culture, benefits package, etc.

Use Glassdoor.

An amazing website with everything you need to know. Pay.  Salary.  Company culture.  Interview questions.  You name it.

Relationships, not cover letters.

I hate writing cover letters, didn't write any, and had no problems what-so-ever.  My beef with them is that they are a formality that state the obvious, and have to follow a weird sort of corporate/business/overly-formal tone.  I focused on connections, contacts, recruiters, and relationships instead.  I would argue most of the hiring managers I worked with didn't seem to care about whether I had a cover letter.  If you have skills, experience, and connections, a company will pursue you.  If you don't, they won't.  A cover letter won't make any difference.  Maybe they are needed if you are a fresh-out, or in another industry than computer engineering.  But for me, nope.

Not decked out, but preppy.

It is better to be overdressed than underdressed, but your attire should come in close to those that interview you.  I wore business casual slacks, a button-up shirt and tie, with a collared sweater.  With engineers in the pacific northwest, I think this is as classy as it gets.

Last (and most important): don't dwell.  Let it go.

Getting a new job is the easy part.  The hard part is to not dwell on all the details of what happened.  There are the questions that will haunt you.  Who made the decision?  Why were we chosen?  Why did they get to stay? What did we do wrong?  What could I have done? And the statements.  We all worked so hard.  Bad f'n choice.  If they only understood everything I did.  It is okay to think these things.  But then take a deep breath, let go of the thoughts, and understand what is done is done and now it is in the past.  And, when you get hired again, odds are the growing company that has added you to the workforce will have a much better environment than the shrinking company that let you go.

For those that are laid off going through the struggles of wondering how they will support themselves and their family, I hope this helps, I feel for you, and good luck!

Thursday, June 13, 2013

Poor Designing

It's that time of the year again!  Time to start blogging.

I have noticed a trend of "poor designing" at most places I have worked at.  Note that I am not saying "poor design" but "poor designING".  At the end of the day a product often turned out okay, but at varying expense (schedule or cost overrun, turnover, etc) due to bad designing.  Sometimes the end product doesn't turn out okay.  I briefly want to jot down what bad designing is. Maybe this will help you identify when your company is bad at designing--recognizing there is a problem is the first step.

Side note: By desigin I mean technical design.  As far as touch/taste/visual/feel design of a specific product, that is a whole different category.

Bad designing is when you don't have a medium to store your design.
Often times a great technical design comes to fruition, but it isn't stored anywhere.  Efficiency goes down the drain when the same decisions have to be re-hashed again and again via boring meetings.  Whether it is a requirements word document, a complex feature/specification/requirements tracking piece of software like DOORS, or set of power points, a solidified design needs to be documented somewhere.

Bad designing is when you don't plan ahead.
Any project is going to have a "design as you go" mentality.  There is simply no way to envision everything that possibly needs to be considered.  But to what level you design as you go can vary depending on how much time is spent on planning ahead.  And when you don't plan ahead, reject feature creep, and keep everything scoped, you have to design everything as you go.  Designing everything as you go = pain.  How can you predict development schedule and cost when the end-technical-design changes on a daily basis?

Bad designing is when key decisions are made by personality.
Key design decisions need to be made by things such as technical merit, trade studies (evaluating trade-offs between features, schedule, cost, marketing, etc) and a team of qualified individuals coming to a consensus.  Often though fundamental design decisions are made by whoever has the "strongest" (aka douchiest) personalities.  In a poor work environments, product life or death technical decisions are made in backrooms that exclude important schedule/cost/technical whistle blowers.  Design decisions have several stakeholders that each bring a consideration to the table.  These considerations--the pure data and strategy--should be what drives the decision.  Personality shouldn't be part of the equation.

Bad designing is when you don't recognize you are designing.
I've been in a meeting where everyone goes in circles about how bad things are that you have to spend so long to visit a technical aspect and tear it down (to discover it was more complex that what was originally assumed).  Spending 3 hours to have a large discussion that tackles a technical glitch discovered in a meeting that was supposed to take a half hour, or to dig into the we don't know what we don't know questions, is time well spent designing.  As I mentioned before, to not design as you go is impossible in any project.  Instead of rejecting the fact you are designing, embrace it, organize it, and accept it.

Designing is hard.  It requires good company culture, creativity, responsibility, planning ahead, and a process.  The design process is often overlooked by the thing that is being designed.  Everyone just cares about where the project is at on a given day, not how it is being developed.  I'm hoping that by listing what bad designing is you can take the next step on improving how you design.

Friday, July 20, 2012

Things you don't Learn in College #2: Talk it out when Tensions are High

Okay, this next post should be much more readable than the last to non embedded software people.  Talk in person if someone is angry, or you are angry is the ideaThis is a generic piece of advice you have probably already heard.  Now that I'm at writing generic stuff, I might as well write for MSNBC articles such as "5 ways to be healthy... one, eat well, two, excercise, three get a good nights rest, etc.".  But my hope is that writing my thoughts and experience trying to follow this advice will further elaborate and affirm its importance.

How I Learned: LogicPD

Going back to when I was an applications engineer at LogicPD, I was very close to the "front line" of customer support.  My pal Aaron's resposibility was to qualify potential customers, and shield us from problem customers.  Sometimes times customers would sign up to contract their development out to us, and I often was the guy to help them out.

When in this environment, inevitably you will have to deal with an angry customers.  There are many fish in the customer sea.  Some will be angry for good reasons, such as misleading or "swiss cheese" documentation.  Others are just, well, crazy.  I remember Aaaron saving emails that we deamed "gems".  One of our favorites was one that ended "THIS IS UNEXPECTABLE@!!!!!" (I'll leave it to you to do the translation). 

When this happened, I remember the first thing my leader at the time (Mr. Rempel, who would leave to start Exosite) told us to do was to give them a call on the phone.   And almost 100%, the tension that was in the email didn't come through.  Things could worked out, person to person.  To this day this has stuck with me, both inside and outside of work.

Why it Works

There is so much more communication that happens in person compared to email.  Your tone of voice, your facial expressions, eye contact.  When this is lost, each party fills in the dots.  Dots can be filled in correctly or incorrectly.

More fundamentally, when you communicate over email, you are sending and receiving words from and to a peice of software.  You are in your own head and not communicating with another human being in the moment.  When you talk in person, you never loose site that you are talking to another human being.

Why it is Hard

Like most peices of generic advice, it is easy to listen to, agree with, and accept.  But the act of looking someone in the eyes, not having the leasure of planning and brainstorming each sentence in an email, and telling your true feelings on something is hard to do.  It requires improvising, not overthinking, and courage.  If the person to talk to is someone who you are intimidated by (I've found this inside and outside of work), getting everything out that you are thinking is very hard.  This is the core issue with fear/intimidation management styles.

Beyond the difficulty of actually doing it, simply changing habbits and behavior is very challenging too.  It took a couple "lessons learned" for me before doing this sunk in and stuck.

Why Conflict is Unavoidable

You will never work in a workplace without passionate people.  You will never work somewhere where everyone has the exact same personality.  Even if you are king at avoiding conflict, things will arise at some point in your career.  This is fundamental to being a human being, and working with human beings.

More Tips
  • Write down bullet points in your notebook of the key things you want to convey and follow it during the discussion.   Keeping focus when talking in person can be challenging, and could require persistence and steering.
  • Read and learn about NVC and NVC in the Workplace.
  • In case you forget or realize your built-in habbits aren't changing because of this blog post, get a reminder tatoo backwards on your forehead.  Sometimes that daily note when you look in the mirror is just what is needed.  :)
That's it for this week.  I can't decide whether I want to write about dealing with imperfection or the top 6 people I owe my career to nextStay tuned!







Thursday, July 5, 2012

Things you don't Learn in College (#1)

In 2004 I got my degree in Computer Engineering from Portland State University.  When I graduated, I was lucky enough to get a job in my field right off the bat.  With 8 years of Embedded System experience behind my belt, I often look back at what I never learned in college.  To get myself to write in here more frequently, I will take my time and write a series of posts about what I do on the job now that I didn't learn in college.

At PSU, and I bet at most college undergraduate Computer Engineering programs, you don't learn about Bill of Material (BOM) management.  And by BOM Management, I mean part numbers, model numbers, assemblies, sub-assemblies, engineering change orders (ECOs), etc.

For pure, high-level software development, this isn't necessary.  Your software is installed on a operating system, there isn't parts to keep track of.  But when you are writing hardware specific software, understanding how part management and change control is essential.  IE: When your firmware is ready for production, how do you add the binary release to the PCB BOM?  If you need to revisit a binary release from a past product, how do you pull that up?  How do you trace that binary, contained (often as a document) in a BOM, back to source control?  How do you get the exact manufacturer part number and spec of a sensor your software controls?

I remember the "on the job training" when I started at LogicPD, which involved using Agile (now owned by Oracle) and having a huge headache trying to understand how each part on a PCB has a part number, part numbers are grouped in a BOM, which also has a part number so that can be contained in another BOM.  This creates a hierarchy.  Then - change management, when you rev a part number versus create a new part number, and assessing whether a new part is form fit or function equavilient of an old one.  Sprinkle in manufacturer part numbers associated with internal part numbers, and reving a part number of BOM with an ECO.

A class or two on this would have been probably a little more important than say, the year of solid state physics I took.  I remember this series of classes being rediculously specialized.  It would have been great if I were getting a PHD, with a career of being a wafer/silicon scientist.  I guess it goes to show who PSU's biggest doners are (ahem, Intel).

Okay, stay tuned for more!

Saturday, May 19, 2012

Embedded Software Versioning

Ureka!  I've been thinking about the best way to version embedded software when you release it.  Here you go:

Major.Minor.Sub

Major corresponds to the PCB or product build.
Minor corresponds to the release number.
Sub corresponds to the release iterative release if the Minor number has been branched.

Major
So you are building a product.  There will be 4-5 different prototype  builds of the product before it hits production.  The major number represents the prototype build the software will programmed on.  This could be just for the PCB, or a prototype build of the enitre product.  Usually these are a big deal, thus getting the major revision.

Minor
Minor is for subsequent software releases number after the build.  So the third prototype build comes back with your software preprogrammed on it (version 3.0.0).  Then you make more releases intended for this build (3.1.0, 3.2.0, 3.3.0) as development and testing continues.

Sub
Sub is if you have to branch a minor release to keep the software stable if there are any major features to be added between minor releases.  Ie 3.1.1, 3.1.2, 3.1.3 gets released for tester to regress bugs, while the code is taken apart and put together again for release 3.2.0.  Then of course, all the xx.1 xx.2 and xx.3 changes will need to be merged in at some point.

Another way to describe this: Major subdivides the project by hardware build, Minor subdivides it by software releases, and sub allows a scheme to fix bugs and do sub releases to QA

Yes, this is very similar to regular software version numbering.  But the major is associated with hardware platform.

Would everyone agree with this scheme?  Probably not, and I think that is okay.  You see, revision numbering isn't a one-size-fits-all system.  It all depends on the end-user of the version number.  Who will be using the version number, and what organiziation concepts they will expect of it.  This isn't the same for every industry.

Okay, time for some rest.

Wednesday, March 21, 2012

Firmware Interview Excercise

Recently I thought of a good job interview excercise for a potential firmware engineer. Here is the excercise for your use, plus guidlines of how to grade it:

Write on the whiteboard C/C++ code to read a memory mapped register, clear a bit, then write it back.

Things I don't care about:
  • If there are any simple syntax errors or missing semicolons.
  • The variables types used, as long as the candidate knows how many bits they are (int, versus uint32, versus DWORD).
Things I do care about:
  • Was the "volatile" keyword used when declaring the variable that would point to the register? (I would hope that the value we get from the register is a fresh, uncached value).
  • Did the candidate ask how big the data bus of the system is? (How else would I know how the pointer type?)
  • Was it second nature to use the "wordwithbittoflip &= ~MASK" convention.
  • Did the candidate ask whether a MMU is being used? (need to make sure you are accessing physical memory, not virtual)
  • Did the candidate ask what OS is being used, if any? (tracing back to the MMU question, if there is one being used, getting access to physical memory will vary from OS)
Bonus points:
  • The candidate uses bit banding for increased speed.
  • The candidate wonders if the system is big or little endian when setting up the mask.
Next chance I get to interview someone maybe I'll give it a shot. It is consistent with Joel On Software guidlines to have the interview candidate write simple, non "gotcha" code. The above should be simple for anyone with embedded experience.

Tuesday, March 15, 2011

serproxy random crashes

For those of you using serproxy.exe to convert serial IO to TCP messages for serial port communication with Adobe Flash scripts, I would avoid using a USB to Serial adapter if at all possible. Stick with the serial port on your motherboard, if you have a desktop computer that still has one.

As I found out while working on some pieces for OMSI's Design Zone exhibit, 2-4 hours of constant serial communication can cause USB to Serial Adapter drivers to raise unhandled serial port errors, thus locking serialproxy.exe, and breaking communication from the Adobe Flash Movies I created to the hardware.

If you are in a situation where you need to use a USB to Serial adapter, the next step would be to update serproxy.exe to properly use ClearCommError() to constantly clear out errors. Without this, writefile() (the function call that communicates directly with the serial port driver) will crash serialproxy.exe.