Matthew Justice’s blog

Programming UNROM-512 with Kazzo hardware (NESDEV)

2022-10-24T10:00:00-04:00

Background

I’m developing a game for the NES, and I recently got a couple of flashable UNROM-512 PCBs from Broke Studio. To program these boards, I’m using the Kazzo cartridge Dumper-Programmer from Infinite NES Lives - this is the older, discontinued version of the hardware based on the AVR / ATMEGA microcontroller. I didn’t have success using the old INL retro-prog v1.1beta.exe software for programming these boards, but the newer software works. In case anyone else is interested, here’s what I did…

Steps

Get the INL retro programmer-dumper software here: https://gitlab.com/InfiniteNesLives/INL-retro-progdump or from the BrokeStudio fork.
Follow the instructions in the readme for installing the driver and updating the firmware on the kazzo device.
As mentioned in the discussion here, get the modified mapper30v2 lua script file and replace the file in \INL-retro-progdump\host\scripts\nes.
With the kazzo device in run mode and the UNROM-512 cart inserted, execute the following command from the \INL-retro-progdump\host directory.

inlretro.exe -s scripts\inlretro2.lua -c NES -x 512 -m mapper30v2 -p <path_to_nes_file>

Important: the input file should be a full NES file, not just the PRG binary data. It needs to include a NES header.

Example output

If everything works, you should see output like so:

Successfully found and connected to INL retro-prog
Device firmware version: 2.1.x
firmware app ver request:       3
checking for old firmware
later firmware sensed, running current script
Testing         MAP30
attempting to detect NES/FC mapper via mirroring...
vertical mirroring sensed
detected RAM @ PPU $    1000
EXP0 pull-up test:      15
reading PRG-ROM manf ID
attempted read PRG-ROM manf ID: BF
attempted read PRG-ROM prod ID: B7
CHR-RAM BANKING TEST PASSED

erasing MAP30
42      naks, done erasing prg.

Programming PRG-ROM flash
writting PRG bank:      0        of     31.0
writting PRG bank:      4        of     31.0
writting PRG bank:      8        of     31.0
writting PRG bank:      12       of     31.0
writting PRG bank:      16       of     31.0
writting PRG bank:      20       of     31.0
writting PRG bank:      24       of     31.0
writting PRG bank:      28       of     31.0
Done Programming PRG-ROM flash
total time:     43.374  seconds, average speed: 11.80   KBps

Profiling C code on Linux with gprof

2020-11-24T09:00:00-05:00

Summary: gprof is performance analysis tool for Linux. Use it by compiling your C code with the -pg option for gcc, reproducing the issue, and then running gprof against the previously-generated gmon.out file.

Background

I was writing some cross-platform C code that worked well on my Windows 10 PC, but didn’t work so well on a Raspberry Pi 4 running Raspberry Pi OS. The program would slow down dramatically, and a quick analysis showed that there was a CPU bottleneck. I needed a profiler to help me see where the program’s CPU time was being spent. I decided to use gprof.

Steps

First, your code needs to be recompiled with the -pg option for the gcc compiler. This option needs to be applied at both the compilation and linking step. The -pg option generates instrumentation that tracks function calls at runtime.

Once you rebuild your program, run it again and reproduce the issue. Ideally, allow the slow part of the program to execute multiple times so you get a good sample of the problem. Exit the program, and you should see that a new file was generated: gmon.out. This file contains the data collected by the -pg instrumentation.

The next step is to process gmon.out using gprof. The tool takes two arguments: the executable filename that was used to generate the gmon.out file, and the path to the gmon.out file. This tool generates a lot of output text, so you may want to redirect it to a text file. Run it like this:

$ gprof /path/to/exe /path/to/gmon.out > gmon.txt

Open the gmon.txt file and you’ll see results that look something like this:

  %   cumulative   self              self     total           
 time   seconds   seconds    calls  ms/call  ms/call  name    
 80.01      0.12     0.12      392     0.31     0.31  FunctionA
 20.00      0.15     0.03     2480     0.01     0.01  FunctionX
  0.00      0.15     0.00   169740     0.00     0.00  FunctionB
  0.00      0.15     0.00   144896     0.00     0.00  FunctionY

Considerations

Be careful of how you interpret the results. There’s an explanation in the generated output of the meaning of the various columns. The cumulative time includes calls to other functions, so keep in mind the caller/callee relationship of the functions (the output also includes sampled call stacks, which can be helpful in understanding this). Also, consider that gprof doesn’t track calls made into libraries that weren’t built with the -pg option, so time spent in those libraries may instead accrue to the calling function.

My Findings

Going back to the problem I had on Raspberry Pi, it turns out I had some rather inefficient code that was making too many calls to the OS graphics libraries. On Windows, this problem was masked by the excellent performance of the graphics driver. On Raspberry Pi OS, the graphics stack couldn’t keep up, and the problem became clear. Since I can’t rely on the performance of a particular system’s graphics implementation, I’m going to optimize my own code, minimizing calls to the OS graphics libraries.

Zoom security and privacy - how bad is it?

2020-04-07T14:00:00-04:00

I keep reading news stories about how terrible Zoom is from a security and privacy standpoint. I host a weekly video call, and I’d like to use Zoom since everyone loves it, but should I be concerned about the issues recently uncovered, at least for my own use of Zoom? In this post I’m going to cover the various recent issues (using CNET’s recent article for a list of issues), and give my thoughts on each, focusing on how it matters in my own usage of Zoom.

TLDR: Zoom has made some security and privacy missteps, but these issues won’t be of serious concern to the average user. Be sure to use a password on your meetings and only share the meeting link with people you trust. That said, given the number of recently discovered issues, there may be other problems lurking in Zoom’s code, so take note of new issues as they are reported.

Recent Zoom Issues

Zoombombing and Zoomraids - Troublemakers like to jump into Zoom calls and do bad stuff. This is less a Zoom issue and more a basic internet security issue. If you share a link to the world then bad people might click that link! This isn’t an issue if you password protect your Zoom calls and only share meeting URLs with people you trust. Plus, the person hosting the meeting has additional controls in terms of who to allow in the meeting, who can share content, etc. - use those features!
Automated tool can find Zoom meetings - Someone wrote a tool that can generate valid Zoom meeting IDs, making it easier for people to Zoombomb. Zoom should probably make their meeting IDs harder to guess, but again, password protect your meetings, and this won’t be an issue.
Zoom shares user contact info - Sometimes Zoom treats email domains as company directories, and shares user info among users with the same domain. I think this is a poor design! I’m surprised this was ever released. That said, for me personally, it is a non-issue since my email address is on a well-known email domain and is excluded from the “feature.” Still, I’d like to see Zoom remove this capability.
Facebook data sharing on iOS - In their iOS app, Zoom previously relied on the Facebook SDK to allow users to sign in with their Facebook account. This had a side effect of the app sharing certain device details to Facebook. I understand that people do not trust Facebook at all, but for my own usage of Zoom I’m not terribly concerned. Plus, Zoom has issued a fix for this.
Lack of true E2E encryption - This is a bad marketing move, with Zoom apparently saying they support end-to-end encryption when they really don’t. I never expected E2E encryption in Zoom, and the encryption which Zoom uses is good enough for me. See Zoom’s clarification on their encryption.
Calls routed through China - This was apparently a temporary misconfiguration on Zoom’s end where non-Chinese users had calls that connected to Zoom servers in China. Not great, but also not terribly alarming for me.
Zoom accounts found on the dark web - It is unclear where the leaked account info originated. I suspect that the accounts were compromised by the usual methods (password re-use, phishing, etc.). If it came to light that Zoom is leaking account credentials that’s a much bigger concern.
Recorded Zoom videos on the web - Some people record their Zoom meetings and upload them to a non-secure location on the web. Yeah, don’t share your private recordings on the public web! I almost didn’t mention this one, as it is clearly user error, but I included it since news sites are reporting on it.
LinkedIn data-mining feature - Zoom matched users to LinkedIn profiles under certain circumstances. I can see how this one is concerning, although given the audience of my Zoom meetings, it wasn’t an issue. Zoom has issued a fix for this.
Windows password theft - Zoom was converting UNC paths to clickable hyperlinks in chat. If a malicious user was in your chat, and that user posted a UNC path to an internet location, and you clicked that link, then they could steal your Windows username and password hash. Common sense: don’t click hyperlinks to untrusted servers (especially UNC links) from random users! Don’t ever do this, not just in Zoom! Also, don’t let untrusted users into your Zoom chats. Zoom has issued a fix for this.
Mac privilege escalation to root - A local unprivileged attacker may be able to escalate their privileges to root (details). That’s bad, but at least this is a local security issue - the attacker has to already have a foothold on the system. My personal take: I don’t use a Mac, but maybe some of the people in my calls do. Zoom has issued a fix for this.
Mac webcam vulnerability - On a Mac, a local attacker can inject code into the Zoom process and leverage Zoom’s mic and camera access. That’s bad, but at least this is also a local security issue - the attacker has to already have a foothold on the system. Zoom has issued a fix for this.

Keep using Zoom?

When I look at these issues individually, none of them are a deal breaker for me. If you’re running the current version of the Zoom app, the fixes mentioned above should be automatically installed. Zoom is easy to use and people have quickly picked it up. I plan to keep using Zoom.

However, looking at these issues in aggregate does worry me. It would seem that Zoom has not historically focused on privacy and security, and so I’m concerned about what else may be lurking their code. I’m going to keep using Zoom for now, while keeping an eye on new issues as they arise.

To Zoom’s credit, they are taking 90 days to fix issues and pause feature work. I wish their engineering team success.

I’m primarily looking at these issues from a consumer perspective. If you are using Zoom in a business scenario, particularly one where confidential information is shared, your evaluation criteria will differ. If your company already has an approved solution for video conferencing - use it!

Installing adb

2020-03-29T09:04:00-04:00

Today I wanted to diagnose a problem on my Android phone. It had been a while since I wrote any Android code, so adb wasn’t installed on my computer. I decided to just quickly install the Android command line tools, rather than the full SDK. This turned out not to be so quick after all. In the end, I had to download the tools, extract them into a particular folder hierarchy, move some files around, install Java, and set some environment variables. It’s like someone was trying to make this difficult! Here’s what worked for me on Windows 10. Maybe it will help someone else.

Downloaded and Installed the Java Runtime Environment (currently version 8 update 241).
Download the latest Android command line tools. That’s commandlinetools-win-6200805_latest.zip at the time I’m writing this.
Extracted to C:\android\cmdline-tools\latest, following the guidance here. To clarify, the downloaded zip file contained a folder named tools, and I renamed that folder to latest and placed it in C:\android\cmdline-tools. Why would a specific folder structure be required? I don’t know, and I’m not taking the time now to investigate.
Followed the advice here and copied the files in latest\lib\_ to latest\lib. This doesn’t feel right to me… why would the zip file include a folder structure that doesn’t work? I’m sure there’s more going on here, but for now I’m going with that works.
Added an environment variable named ANDROID_HOME and set it to C:\android\cmdline-tools\latest.
Added %ANDROID_HOME%\bin to my PATH.
Opened a cmd prompt and ran sdkmanager "platform-tools". This installed adb and more to C:\android\platform-tools.
With my Android device connected to my PC with USB debugging enabled, checked that adb is working by running adb devices.

That took more effort than I expected, but at least adb works now!

Migrating from WordPress.com to Jekyll and Netlify

2019-02-03T16:23:39-05:00

When I started my personal blog in 2016 I wanted a simple solution. I built software for a living, and I didn’t want to deal with writing code for a simple blog. WordPress.com provided a good platform for this. It was $13 / year for the privilege of using my custom domain, which seemed OK. It was fine for what I needed, but after a while I got tired of the ads, and didn’t really want to pay more.

Now, three years later, I’ve taken an interest in static site generation. I began reading up on Jekyll, and I liked the idea of generating a static site based on simple markdown. I also learned about Netlify, and I became a fan of their continuous deployment and integration with GitHub. The idea of updating my blog by simply pushing to GitHub sealed the deal for me. I decided to migrate off WordPress.com and onto Netlify, generating my site with Jekyll and managing the code in GitHub.

Turns out I was able to migrate this blog in an afternoon! Here’s how I did it; maybe this will be helpful to someone else.

First, I exported the XML for my WordPress.com site using the URL below (replacing BLOGNAME with my WordPress blog’s name)

https://BLOGNAME.wordpress.com/wp-admin/export.php

I then created a new GitHub repo and cloned it

$ git clone reponame
$ cd reponame

Installed Ruby and Jekyll.

Created a new Jekyll blog in my local copy of the repo

$ jekyll new blog
$ cd blog

Installed jekyll-import and prerequisites

$ sudo apt-get install zlib1g-dev
$ sudo gem install hpricot
$ sudo gem install open_uri_redirections
$ sudo gem install jekyll-import

Copied the WordPress.com XML as wordpress.xml into the new blog directory.

Ran the import tool

$ ruby -r rubygems -e 'require "jekyll-import";
    JekyllImport::Importers::WordpressDotCom.run({
      "source" => "wordpress.xml",
      "no_fetch_images" => false,
      "assets_folder" => "assets"
    })'

Ran the Jekyll site locally for testing

$ bundle exec jekyll serve

Some cleanup was required. Namely:

In _config.yml set the following so that link URLs would be the same as the old WordPress URLs:
```
permalink: /:year/:month/:day/:title/
```
I set the timezone in _config.yml to ensure that permalinks generated on the server would be as expected.
Many of the images were weirdly sized or positioned. I removed width and height attributes on img tags and removed unused CSS classes. I also added some CSS classes as needed.
Image galleries weren’t imported at all. I manually downloaded the missing image files and then used this helpful tip to enumerate the images in blog post.
Certain linked files weren’t imported. I manually copied them and fixed up the links.
Comments didn’t come over either, but I only had a few so I manually copied their text. I haven’t added a means of adding new comments.
I made some minor changes to the look and feel of the site.

Once I had the site running satisfactorily locally, I pushed to GitHub and set up a new site on Netlify that deployed from GitHub. Then I switched the DNS record for blog.mattjustice.com to point to Netlify rather than WordPress.com. All pretty straightforward!

GDB commands for WinDbg users

2018-08-24T22:03:01-04:00

Most of the debugging I've done has been on Windows using WinDbg (or kd, cdb, ntsd). Now I'm doing some GDB debugging on Linux, so I'm trying overcome my muscle memory of typing WinDbg commands. I'm sharing my table for translating WinDbg commands to GDB.

Action	WinDbg	GDB
`Set breakpoint`	`bp [addr] bp [name]`	`b[reak] *[addr] b[reak] [name]`
`List breakpoints`	`bl`	`i[nfo] b[reakpoints]`
`Enable breakpoint`	`be [n]`	`en[able] [n]`
`Disable breakpoint`	`bd [n]`	`dis[able] [n]`
`Clear one breakpoint`	`bc [n]`	`d[elete] [n]`
`Clear all breakpoints`	`bc *`	`d[elete]`
`Disassemble`	`u u [addr]`	`disas[semble] /r disas[semble] /r [addr]`
`Run`	`g g [addr]`	`r[un] sta[rt]`
`Continue`	`g gc`	`c[ontinue]`
`Restart`	`.restart`	`r[un]`
`Trace (into calls)`	`t`	`s[tep]`
`Step (over calls)`	`p`	`n[ext]`
`Trace (into calls) by machine instruction`	`t`	`s[tep]i`
`Step (over calls) by machine instruction`	`p`	`n[ext]i`
`Toggle source mode for stepping`	`l+t l-t`	`n/a - See above. (use si and ni`)
`List modules`	`lm`	`i[nfo] sh[aredlibrary]`
`View registers`	`r r [name]`	`i[nfo] r i[nfo] r [name]`
`View call stack`	`k[b\|v\|p]`	`i s[tack] bt f[ull]`
`View threads`	`~`	`i[nfo] th[reads]`
`Switch thread`	`~[n]s`	`thr[ead] [n]`
`View all thread stacks`	`~*k`	`thread apply all bt`
`Switch frame`	`.frame [n]`	`f[rame] [n]`
`View memory (8 bytes)`	`dq [addr] L[n]`	`x/[n]xg [addr]`
`View memory (4 bytes)`	`dd [addr] L[n]`	`x/[n]xw [addr]`
`View memory (2 bytes)`	`dw [addr] L[n]`	`x/[n]xh [addr]`
`View memory (1 byte)`	`db [addr] L[n]`	`x/[n]xb [addr]`
`View memory (ascii)`	`da [addr] L[n]`	`p[rint] (char*)[addr] x/s [addr] x/20c [addr]`
`View memory (stacked)`	`dds [addr] L[n]`	`x/xw [addr] repeat Enter key`
`View local variables`	`dv /v x`	`i[nfo] lo[cals] print [var_name] x &[var_name]`
`View global variables`	`x [mod]!*`	`i[nfo] va[riables] info address [g_name] print [g_name] x &[g_name]`
`View frame args`	`x kP L1`	`i[nfo] ar[gs]`
`View type`	`dt [type]`	`explore [type]`
`Break on syscall`		`catch syscall [i] catch syscall [name]`
`Set register`	`r [name]=[value]`	`set $[name]=[value]`
`Evaluate`	`? [expr] e.g. ? rax+5`	`p [expr] e.g. p $r11+5`
`Quit`	`q`	`q`

Notes:

GDB: Prefix breakpoint memory addresses with *
GDB: "set disassembly-flavor intel" for disassembly more like WinDbg
GDB: "start" runs to the entry point (if named "main")
In the View memory commands, "n" represents the number of values
For viewing local variables, be sure to compile with symbolic information:
- - gcc -g
  - cl /Zi

The Desktop Heap Guy

2018-07-26T11:14:50-04:00

When I worked at Microsoft as an Escalation Engineer, I spent my days analyzing various failures in Windows. My team was called CPR, Critical Problem Resolution, and we were there to debug issues discovered in Windows by Microsoft's customers. These problems came to my team because they were either "critical situations" for a business customer, or because the issue was particularly technically challenging.

In this role I worked on all kinds of weird failures, but one type of issue became a regular thing for me: desktop heap failures. I didn't set out to be an expert on desktop heap, but when a more senior engineer on my team decided that someone else needed to understand desktop heap, I was asked to become the subject matter expert.

I started investigating every customer case that looked like the root cause might be a desktop heap failure. The symptoms were usually one of two things:

1. Processes would fail to start altogether.
2. An application would run but certain windows would fail to display.

This was perplexing for users and developers alike. The underlying cause wasn't obvious, and the same software that had previously worked without issue would suddenly start failing. There was already some limited documentation on this problem, including a KB article, but I needed more information if I was going to really understand the problem and help customers.

I quickly learned that only a handful of people at Microsoft actually knew anything about desktop heap! So I studied the Windows source code, reached out to some other engineers on the Windows team, and began to pull together an understanding of the problem. I continued to get involved with every reported desktop heap failure, and eventually I became the unofficial Desktop Heap Guy. Within Microsoft support, people had learned that there was this person who actually wanted to help with desktop heap issues! This of course led to me getting even more cases to investigate.

Eventually I decided that we really needed some documentation on desktop heap. This led to me writing series of blog posts, and recording a Channel 9 video. Even better, changes were made to the memory manager in Windows Vista and Windows Server 2008 that helped avoid the problem altogether, and the problem mostly became of thing of the past. Even so, for years after I left the Escalation Engineer role at Microsoft I would still get questions about desktop heap. Once the Desktop Heap Guy, always the Desktop Heap Guy, I guess!

That's me, explaining desktop heap in 2007

Handy MCU Infinity Stones Worksheet

2018-07-19T11:38:37-04:00

I'm watching the Marvel Cinematic Universe films with my older kids, and we are tracking the infinity stones as they appear. To help with this, I made an Infinity Stones Worksheet for them and an answer key for me. Enjoy!

Luke Skywalker Needs a Wife

2017-12-21T09:29:43-05:00

Star Wars: The Last Jedi was beautifully filmed and full of surprises. I enjoyed the film, but it had some issues. There's a lot I could say about it, but for now I want to talk about one character: Luke Skywalker. When we met Luke in the original trilogy, he was full of hope, willing to rush off to save his friends, and ready to confront evil on the slim chance that he could redeem his father. Luke didn't give up easily. Who is this guy in The Last Jedi? Scared, in hiding, selfish. Sure, he arguably gets his act together by the end of the movie, but really, I'm disappointed in you, Luke.

While discussing this with my spouse, it became clear what went wrong with this version of Luke. He needs a wife! Specifically, he needs Mara Jade! Would Mara have allowed Luke to wallow in self-pity? No, she would have kicked him in the head and said "Get up farm boy; you are better than this!" Would Mara Jade have let Luke's nephew to go dark without confronting him? No! She would have ambushed him in her StealthX starfighter and fought him in the tunnels of Kavan! OK, that's a very specific reference and it didn't end well, but you get the idea! Would Luke have been so self-centered if he had a wife? Of course not! Would Mara have allowed Luke to seemingly waste 30 years after the battle of Endor? No, she would have pushed him, challenged him, and made very sure he was able to continue the Jedi Order!

Life is so much better with an awesome wife. Poor Luke in The Last Jedi; if only he had a wife.

Comments

David Cole - December 21, 2017 at 5:35 PM

***spoilers***

With all the push for more strong female characters in Star Wars, it’s really very surprising that Mara Jade has been seemingly completely deleted. Also while I enjoyed The Last Jedi, I really feel like it has jumped the shark. They’re going to have to shock me in the next trailer to get me excited for the third installment the way I was about this one. While Rey, Finn, Po, and Kylo Ren are interesting characters, I just don’t feel the same interest in their fates as I did with Han, Leia, and especially Luke. And while, yes, they gave him one of the most epic last stands anyone could have wished for, the fact that his story is “done” has me really scratching my head about what I can get excited about in the next movie.

Matthew Justice - December 21, 2017 at 8:52 PM

Yes, I have similar feelings about it. Interesting choices were made to leave TFA’s “mystery boxes” unopened (or opened with nothing inside), and then wrap up things as they did.

Why I’m leaving my job at Microsoft

2017-11-26T20:28:19-05:00

My last day working at Microsoft will be December 1, 2017. I'm not taking another job right away. Instead, I'm blocking off time to pray, to invest in my family, to study, and to work on some projects. As I've shared this news in recent weeks, I sometimes get confused looks. "Why?" is the general question. "Why leave a perfectly good job with no other work lined up?" Great question! What follows is my answer.

I began working at Microsoft in the fall of 2000, a few months after finishing a degree in Electrical Engineering from the University of Tennessee. My first role was as a Support Engineer for Windows. I can easily remember how excited I was to get this job! Microsoft was the only software company I interviewed with; all the other companies I considered were hardware-focused, which was more aligned with my education. And yet… Microsoft… what an opportunity! This was a company that was changing the world, and I wanted to be a part of it.

Over the next 17 years my career at Microsoft as a software engineer took a variety of interesting turns. Some highlights: I debugged Windows and worked on hotfixes, helped develop "Fix it", led a team of engineers who built diagnostic tools and services, and led an engineering team building services for Microsoft's financial systems. Through all of this I found that not only is Microsoft a place to do incredible technical work, but perhaps more importantly the people at this company are amazing. They are intelligent, technical, collaborative, driven… these are my kind of people, and I've learned so much from them over the years.

Why would I want to leave a company like that? There are actually several reasons, but when distilled down it comes to one thing: I want to be intentional. Microsoft has been incredible, but I came to realize that I've allowed myself to be swept along in my career, taking each opportunity as it came, without stopping to consider where I'm going.

I'm choosing to be intentional in how I spend time with my family. My wife and children are the most important people in my life, and they deserve more of my time and attention than they have received in recent years. As I've taken on more responsibility at work I've found it increasingly difficult to maintain a healthy work / life balance (or just "life balance" as a leader I respect calls it). Right now, all four of my kids are at home, and I've come to realize just how precious, and limited, this time is. It won't be long before my oldest kids are in college. If I wait until normal retirement age to take a career break, my kids will be grown. I'm choosing to spend time with them now, even if it means I have to work more years overall.

I'm choosing to be intentional in what work I do. Software engineering has been a good fit for me, but right now I've lost much of my passion for it. I still have a love of technology, but I'm no longer excited about the day to day details of my work. As a manager at Microsoft, I cannot lead effectively if I'm not genuinely excited and passionate about my team's work. I have other interests and abilities outside of software, and I plan to use my time to study and grow those skills, and consider other career paths. Or perhaps doing so will lead me back to software engineering as my true calling, and I will be happy in the knowledge that I took the time to make a deliberate career choice.

I'm choosing to be intentional in how I seek after God. I'm a Christian, but too often I trust in my own abilities rather than in God. I make too many decisions just based on my own logic, and not on faith. As I leave my job and step out of the comfort of regular income and a clear plan for my career, my intent is to be more deliberate in the time I spend in prayer and study of the Bible, seeking God in how I may be involved with the work of his kingdom.

All of that said, I realize that leaving full-time employment is not a prerequisite for being intentional! However, as mentioned above, I need a change. While I could jump to another similar position at Microsoft or elsewhere, in doing so I would miss the opportunity to pause, fully consider what is next, invest in my family, and seek God.

I'm thankful that I had the chance to work at Microsoft; it truly is a great company full of exceptional people. I don't take my decision to leave such an organization lightly, and I recognize that I am blessed to even have the option to take time off from regular work. I plan to make the most of the opportunity!

Comments

mrwhiskernc - November 30, 2017 at 9:24 PM

Proud Dad here.

Aritra DattaGupta - November 30, 2017 at 9:51 PM

Matt, It was really a pleasure getting to know you, to work for you and with you (albeit briefly). I hope our paths cross again soon and as I told you earlier as well, I would love to work with you again.

Oneibus - December 1, 2017 at 1:00 AM

Thank you Matthew for all you have done for me! You are one of the finest people with which I have ever had the privilege to work. I feel even more honored to call you my friend. I hope our work paths cross again some day. Best of everything to you and the family and enjoy the journey! 🙂

Rebecca Christianson - December 1, 2017 at 1:00 AM

Good luck in your new adventures, Matthew! You never know, our paths may cross again someday. Take care of yourself and your family.

Carl - December 1, 2017 at 11:10 PM

Good luck to you sir. I learned a lot from you many moons ago, and it was a pleasure to work with you. Hopefully whatever you choose will give you newfound happiness and purpose.

Vidyadhar - December 3, 2017 at 4:03 PM

Though it was very short period compared to long journey at Microsoft, your leadership will be missed at work. But, one of your ‘Intention’ with family is so true that many of the software geeks are already in the mode of ‘life as it takes’. It takes lot of courage to take such an important decision. Good luck with all new paths you would take!