Ask HN: What does an electrical engineer actually do at work?

- Work on Schematics and layout for various different boards (usually only get time for one each day). - Go to meetings with multiple different engineering teams to make sure that cross-functional requirements are being met (usually the software and mechanical guys making demands of what they need which just means what they want to make their life easier by making the EE's suffer). - troubleshoot issues on the already built hardware and add the fixes to upcoming revisions. - Argue with purchasing department about the reason I need to get a certain type of testing equipment.

-A lot of component research and validation and meetings with vendors to determine if that components is right one.

and this is just the pure hardware tasks. There is always potential to have to deal with firmware issues as well.

I may spent half my day at my desk, at least an hour or two in a lab and the rest is for meetings.

Generally, "embedded systems" implies some programming as well, but I do little to none of that. I think I'm the exception rather than the rule in that sense.

If you wanna get simplistic about it, I spend half my time playing "connect the dots" in overpriced software, and the other half arguing with people about where I decided to put the lines.

On the one hand, there's a lot more standardization in the components I string together to make a working system. On the other hand, it can be just as hard to track down the source of a problem. You happen to have caught me at a point where I'm stuck trying to figure out the proper answer to a mysterious boot issue, and let me tell you what - it's about as frustrating as frustrating gets. You have to push yourself to think hard about what you haven't done, even when you've done everything by the book. ("The book" in this context is documentation, design guides, processor reference manuals - things that tell you what to do to get your system working.)

Point I'm trying to illustrate - don't think that hardware is any easier than software. It's very, very gratifying to see something real, that you can hold in your hands, work. Doubly so when people actually use your stuff and tell you how much they love it. (Yay, consumer electronics!)

And when that is not the case, when hardware is going to be built, the decisions about circuitry and methods are increasingly determined in advance with software.

Here's an example -- in my career as an electrical engineer (30 years ago) I designed any number of phase locked loops in circuitry. Now I design them with a keyboard and a computer monitor, [using methods like this](http://arachnoid.com/phase_locked_loop/). The new PLLs work much, much better than the hardware-based ones, as well as requiring far less guesswork and effort.

So my advice is not to abandon a software-based approach, it increases your employability compared to someone who only knows hardware.

When I joined the company, the very first role I was put in was on the core bringup team for a complex ASIC -- that is to say, the team responsible for screening chips, and working on issues that affect all of the individual functional blocks. I joined about a month or two before silicon was to come back. So, I spent the first six or eight months or so at the company in the lab; the first month was spent familiarizing myself with the tools and boards that we'd be using, and then once silicon came back, I spent a bunch of long nights and weekends in the lab getting chips to various teams, and, in general, solving whatever system-wide problems showed up. Bringup was a lot of work but it was also a really good view into "how the sausage was made", so to speak.

After bringup, I moved to an IP team [1], where my title was "ASIC Engineer". At the phase in the project that we were in, most of the RTL [2] had already been written, and owners for each sub-block had already been assigned. So my job was to do a bunch of the "checklist" items for netlist quality. For instance, I spent a while reviewing test coverage, and waiving coverage for things that couldn't possibly ever be reached. Or I reviewed tool output that did "clock domain crossing verification" -- basically, the tool pattern-matched on various chunks of code to make sure that they were safe. And yes, I spent some time staring at waveforms, trying to debug our testbench, or any kinds of such things.

I spent a while on another couple bringups, which I volunteered for this time. I enjoyed them, and then gave myself some time off for each to compensate myself for my nights and weekends.

At some point, someone decided that I was a better architect than engineer, which is probably for the better, because I was very slow at checklist items. So at some point I switched to an architect role, which meant that I was responsible for doing the definitions of sub-units, rather than implementing the hardware for them or implementing the testbenches for them. And, in general, the whole specification process is part of the architecture team's job. So, one day, when there was an output quality problem with our block -- it worked as specified, but given that it did some image processing, the image quality had some defect, so the specification was wrong -- I was tasked with spending a few weeks to reproduce it on hardware, find register settings that made it better or worse, and finally, understand what the defect was in the specification, and how to avoid it in the future.

Another task I had as an architect was to do the definition for a sub-unit from the ground up. This was a year or two of work. My primary output, interestingly, was not code, but instead a 100-or-so page Word document that specified how the block was to work, and what registers should program it; the consumers of that document would be the hardware team that implemented it, and the software team that would build the software. And, subsequently, I was tasked with implementing a model of that block in C, which could be checked against the RTL that the design team wrote. Near the end of that project, I wrote validation tests for it, and yes, I then spent some time staring at waveforms helping the design team to understand why their RTL implementation diverged from my C model. (They were, often, right. I am very lucky to work with an extremely skilled RTL team.)

These days, I'm doing more algorithmic research, trying to figure out what should be next for the block that I'm working on. In parallel, I sometimes get on phone calls with, for instance, image sensor vendors, understanding on an electrical level what's going on inside of their next sens...

A design engineer tends to have a batch-oriented life. Typical workflow might be like CAD -> sim -> layout -> debug -> small scale production -> testing -> handoff to production. Of course all of this is as a member of a larger team. Somewhere in there you'll either work on software or firmware or both. I spend about half my time in the lab or field, the rest in my office or meetings.

One bad side of EE is that you can break stuff much differently from software. When the magic smoke comes out, there's no 'svn revert' - you have to figure out what you broke and fix it before you can move on. This always happens when you're in a rush and causes plenty of unplanned late nights. And for additional fun, it's not uncommon for problems to crop up where you just have no way to get at the underlying issue. Datasheets don't have all the info you need, and you can't always figure it out. Sometimes you hit a wall and just have to start over. I used an Atmel processor which had a weird bug in its I2C slave module which prevented it from working properly. Best solution ended up being to go to a different processor, which was incredibly painful.

It's really awesome to be able to hold on to a thing that you built and make it go. Seeing your thing go out in the field and work is very rewarding.

I'd say my EEs spend 50% in design and 50% in debugging customer problems when a board fails in manufacturing or fails in the field.

The answers can be easy (say, a resistor is out of tolerance or the wrong oscillator was placed on the board), or they can be really tough (a transient is killing a FET and locking things up).

I made analog designs, digital designs, power supply designs... Then I started feeling more and more that I designed less and spent more time learning what the chip designers did, as chips incorporated more and more functions that once I did by myself.

So at the end I switched to FPGA design and today my typical workday is coding, debugging, simulating... 95% of the time on my computer. A good friend of mine coined a good phrase: FPGA engineers are SW engineers that disguise themselves as HW engineers. A good joke. But every joke has a bit of truth in it.

After 1.25 years, I realized that I was spending all my life in a lab with no windows, to the smell of toxic soldering fumes, fighting against extremely annoying software (altium & other proprietary overpriced pieces of technical debt). Also, I realized whatever I created needed a lot of work for an unsatisfying outcome (A sound amplifier is less satisfying than some webgl stuff that moves [but it requires a lot more work]). The nice feeling of being powerful when writing software & the instant compiler/interpreter feedback is what I missed the most.

At least, when you are a software engineer, you have more odds of finding a nice workplace, with windows and software you can choose.

The part I miss from electrical engineering is the physics part (But we were only skimming this part anyway).

Finally, circuits are a thousand times less satisfying to me than code. I've seen people for whom it was the opposite. They did not get programming at all, but they were designing circuits at the speed of light with an intuition that I did not have.

Why hasn't someone made good software for EEs to use? And if the have, why do no EEs use it?

EEs also study computer architecture and OS internals in detail, depending on one's emphasis.

But as others have said, EE jobs run the gamut. Depending on where you go to school and what emphasis you choose, you could be doing digital IC design (which contains multitudes within itself, e.g. high-level architecture, clock trees, verification, integration), analog IC design, RFIC design, board-level RF, chip package design, embedded systems, power electronics, antennas, FPGA, HDL/IP cores, test engineering, digital signal processing, control theory, communications systems -- the list goes on and on.

The hardware job seemed more like "real" engineering -- it was more rigorous, there was less room for error or experimenting. But, I got bored with it eventually -- it was the same thing, just a bigger chip, more people working on it, and a longer design cycle from one thing to the next. Also, it seemed like upward mobility was hard -- I didn't want to be a middle manager anyway, and it felt hard to have a large influence in a company with thousands of engineers. In the end, I felt I didn't want to die at that desk, so I switched into working for internet startups.

The software end of things has felt more creative and has definitely been more fun. It's more laid-back, people are generally a little more interesting and well-rounded, and you typically work at a place 2-4 years and then move onto something new -- which I like. You're generally working in smaller teams and you get to work on a variety of different pieces of the system if that's what you like to do.

All in all, they were both rewarding experiences with good compensation -- the software thing might end up being more lucrative in the end and I just sorta have more fun doing it. At the time I made the switch, I took a pretty large pay cut going from a mid-level hardware engineer to a junior software engineer, but it's one of the best decisions I ever made looking back.