Spoiler Alert: It’s just another way to say platform

The 2020 O’Reilly Software Architecture Conference training I attended, which I reviewed here, suggested that we read Thoughtworks’ Radar. In the latest volume, I came across a strange phrase: Zhong Tai. The definition in Radar, ”an approach to delivering encapsulated business models,” wasn’t exactly elucidating. Googling Zhong Tai revealed a dearth of knowledge about the subject on the Western Internet.

A friend, who is fluent in Mandarin, helped me learn more. She determined that the Chinese characters for this are 中台 and linked me to a few Chinese sites discussing it. I plugged the sites into Google Translate and started digging.

There seems to be two primary ways of thinking about Zhong Tai:

1. From a business perspective, thinking of capabilities
2. From a technical perspective, thinking of architecture

A Business Perspective

This perspective is mostly based on listening to the Thoughtworks podcast on the topic. When looking at it from a business perspective, Thoughtworks makes Zhong Tai seem like something between SaaS solutions and whitelabel solutions. The core idea is that you can transfer business capabilities to another organization, internal or external. Internally, this means breaking down barriers between departments to encourage sharing services and resources.

One example of this: if you’re a food delivery company, you’ve already built out a full infrastructure around driver tracking, routing, queueing, and much more. If someone wants to start a makeup delivery company, they could reuse your whole infrastructure around delivery. The Thoughtworks podcast didn’t mention how this “reuse” of business capabilities would work in terms of licensing or who actually runs the servers. It seems like Zhong Tai would be most well suited for a company that owns multiple smaller companies that are similar to one another

A Technical Perspective

When digging into the Chinese web I quickly found that the idea of Zhong Tai is attributed to Alibaba, a Chinese e-commerce giant. They wrote an entire book on Zhong Tai with a title that roughly translates to: The way of enterprise IT architecture transformation: Alibaba’s middle-end strategic thinking and actual combat (ISBN: 9787111564805). I was able to find a copy of the book online and ran it through Google Translate. I read the first chapter and learned about the brief history of Zhong Tai.

• In 2003, Taobao, a C2C website, was founded as part of the company Alibaba.
• In 2010, Taobao launched Tmall, a B2C website which became wildly successful.
• These two websites, although both owned by Alibaba, each had their own e-commerce system. Payment processing and orders were completely different on each platform.
• They realized they were wasting massive resources maintaining them independently so they created a shared business division so they reuse parts of the e-commerce system.*

*Like most of this article, most of my understanding is based on Google Translate. Technical words/concepts don’t translate so easily so I’m making my best guess for some of this.

When looking at this from a technical perspective, Zhong Tai seems to be about doing something that’s already quite common in Western tech companies: creating shared platforms. One company might make a payment platform that could be used by multiple departments or organizations. If that payment platform was made available to the public you might call it Stripe.

Why is it called middle end? A core problem Zhong Tai is trying to solve is that the frontend changes too fast for the backend to keep pace. The idea is that you can create a middle layer (or end) that depends on your platform (or backend). That middle layer can be changed very quickly to keep up with the changes on the frontend. I didn’t find any great examples in reading. However, one example might be: if many teams in a company rely on machine learning (ML), the company could create a platform for training, maintaining, and accessing ML models. A middle end would be built on that platform, and could house business logic and expose data to a frontend.

One recent article harshly criticized Zhong Tai. The author said that Zhong Tai is very expensive and while it may help big companies it will squash small companies. The author claimed that there isn’t any common definition of Zhong Tai, other than that it involves reusing technology. They also felt that it set expectations far too high and didn’t appreciate the complexity and uniqueness of businesses.

Etymology

中台 are the Chinese characters for Zhong Tai. 中 is pronounced zhōng and means middle. 台 is pronounced tāi and means, among many things, stage, but in our case it is translated to “end.” Note: 中台 is also the phrase for China-Taiwan relations so that may cause confusion when translating or searching this phrase.

Conclusion

Zhong Tai, as best I can tell, is the concept of creating platforms that can be shared across your organization, or possibly outside of your organization. When written like that, it isn’t anything new or shiny. Maybe that’s why Zhong Tai hasn’t been well documented on the Western Internet. Maybe I am grossly oversimplifying a complex concept based on poor translations. If that’s the case let me know and I’ll be happy to update the article.

Sources

• Contextualizing Zhong Tai
• Criticizing Zhong Tai
• Thoughtworks Podcast
• Alibaba book on Zhong Tai
• Thoughtworks Radar

In 2015 O’Reilly started their Software Architecture Conference. Five years later, I attended the 2020 O’Reilly Software Architecture Conference in New York City. What follows is a summary of the two day training, a summary of my favorite talks, and miscellaneous thoughts. This was my first endeavor into formal software architecture so I approached this with a fresh mind.

Training

I signed up for the Fundamentals of Software Architecture training by Mark Richards. It seemed like the best fit for my interests since I wasn’t looking for tooling-oriented training. The fundamentals were a good fit for a young engineer like myself. The training was based on Mark’s new book, Fundamentals of Software Architecture, so you can read it for yourself if you want to learn more.

When the training started I was a little leery. It seemed like this might be a training session full of fluff and a smooth talking consultant. That was not the case. Mark quickly dove into the content and started asking questions that helped break down popular assumptions. One such belief is that architects set rules for everyone to follow and lay out some grand plan for the organization. However, an architect is in a more collaborative role. They might set some rules but they also create guidelines and work with engineers and business folks to discover and prioritize system attributes, or ilities as they may be called.

A key theme of the training is that everything is a tradeoff. People are quick to espouse the benefits of a new technology but there is always a tradeoff to using that new technology. The tradeoff is not always easy to find. One way to help find them is through the lens of quality attributes (aka nonfunctional requirements). These attributes should always be determined in collaboration with the business stakeholders.

The training suggested these steps to discover attributes with stakeholders:

1. Show stakeholders a list of attributes
2. Ask them to pick the the ones they’d like to see in their system
3. Ask them to pick seven that are important
4. Ask them to pick three of those seven that should be the highest priority*

*Asking them to rank them would be a fool’s errand. So don’t.

The difference between these attributes may be unclear at first. For example, is elasticity or scalability more important for a live sports streaming service? Like everything, it depends. But understanding the difference between scalability (the ability to easily add more capacity as user base grows) and elasticity (the ability to handle very spiky traffic) is important. As such, it’s necessary to examine these attributes through the lens of architecture.

Throughout the training we engaged in architecture katas. The katas brought the room to life and gave everyone a chance to practice what we learned. They were difficult but a lot of fun and gave us a chance to get to know each other.

Occasionally, we discussed tooling specific to architects. Archunit was the most novel to me. It is a testing library to enforce architecture decisions at a code level. You could create a test to check if the presentation layer is directly calling the persistence layer and, in combination with other CI/CD tools, prevent merging when the test fails.

As an architect, you should focus on expanding your breadth of knowledge or, knowing what you don’t know. The training suggested that it’s more important to know about a lot of technologies and their general overview than to know a lot about a few technologies. If you know one technology really well, you’ll see it as the solution to many problems. If you know many technologies at a high level you’ll know what tools to evaluate to help make the right decision.

Free resources to help expand your breadth of tech knowledge:

• https://www.infoq.com — Covers many tech trends and even has an architecture specific section
• https://dzone.com/refcardz — Refcardz provides concise summaries of technology topics
• https://www.thoughtworks.com/radar — Published twice a year. Predicts and discusses upcoming trends

Expanding your knowledge base is critical for an architect. If you think you don’t have enough time for reading these then try reframing if by replacing every “I don’t have time” with “it’s not a priority.” If you decide it is a priority, you could put that in place by spending 20 minutes each morning to see what’s happening in the tech world before you dig into your email.

We also covered architecture certifications. Even if paying for the certificate isn’t worth it to you, filling out the certification application will show you where there are gaps in your skills and experience. The most widely accepted certifications in the field are from The Open Group and the Enterprise Architecture Center of Excellence.

The second half of the training focused on the nuts and bolts of architecture patterns. We covered the following architectures: layered monolith, microkernel, microservices, service-oriented, event-driven (including mediator and broker topologies), and space-based. We spent time examining the fallacies of distributed computing.

The final topic was communicating decisions. They recommend using Architecture Decision Records, which are kind of like changelogs with reasoning but for high level implementation details.

Talks

The two days of training were followed by two days of talks. Some were just okay and others expanded my understanding of architecture. The not-so-good ones were either too generic or not closely related to architecture. They would be a better fit for a more general software conference.

My favorite talks:

Technical Debt: A Master Class

r0ml Lefkowitz | slides | description

He gave an overview of the history of technical debt, explained why it’s hard to grasp (hint: it’s not something you pay back), and argued that technical debt primarily comes from dependencies.

Maturing an Agile organization with intentional architecture

Nimisha Asthagiri (edX) | slides | description

She primarily talked about how edX has tried to get architects and developers to collaborate. On the surface it isn’t an interesting topic but she gave very concrete examples such as hosting architecture lunches with and without topics and different ways of organizing their “architecture guild” that failed and are still in trial.

Where do great architectures come from?

Mary Poppendieck (Lean Software Development Series) | slides | description

Mary started working at Bell Labs over half a century ago. She started off working on a phone system with redundancy and localization. Years later Google faced similar problems with redundancy at a hardware level. Today we’re going through the cycle again with AI and smart homes.

I don’t understand micro-frontends

Luca Mezzalira (DAZN) | slides | description

Micro-frontends are new to me and this was a good overview. The idea is to adapt Domain Driven Design to the frontend. Instead of having a huge front-end and forcing all the teams to use the same tools, you can create independent frontends. This enables faster deployment of changes and more flexibility for teams. How do you share headers/footers when following this pattern? Luca’s team did analysis and found that those components only changed a few times in the past several years so they decided to copy the code into each (of about 5) frontends instead of complicating matters with a shared code library.

Challenges to internationalize the largest digital bank in the world

Luiz Hespanha (Nubank), Lucas Cavalcanti (Nubank) | slides | description

This was one of the most concrete talks of the conference. They told the story of the Nubank architecture from providing a frontend for an outsourced credit card processor to deploying customized Kubernetes clusters across the world.

Miscellaneous Thoughts

• The organizers talked a lot about networking at this conference and how valuable it is. Do architects collaborate across organizations? I’m curious how this value manifests to architects.
• In the middle of the keynote they stopped for two minutes and asked everyone to talk to their neighbors. I loved this.
• I met great people and talked about mainframes, security tooling, and zhong tai. But it was not easy to choose who to strike up a conversation with.
• For a company that is supposed to showcase the latest and greatest in tech, O’Reilly’s events app is pretty rough 😬
• They sent a lot of emails reminding people to charge their devices before the event. It must have worked because there weren’t many chargers around but the ones I saw were usually available.
• Some tables at lunch displayed table topics such as what’s next?, what do you want to change in your organization?, and gRPC. The topic cards were a nice indicator of who people wanted to talk at lunch.
• There was also a talk that mentioned reactive streams, which is basically a way to give your processor the ability to control the amount of data coming from the source. This was a new idea for me.

All in all, I really enjoyed the conference and got a lot out of it. For the price, I don’t think I could recommend it to anyone who was footing the bill themselves. If your company is willing to pay for it (thanks NYT) then you should go for it. Thanks for reading and best of luck with your software architecture journey.

Goal: Fast Drone tests with pipenv

Problem: pipenv installs requests in a random(ish) directory and install is relatively slow

“The virtualenv’s name is the project’s root directory name, plus the hash of the full path to the project root.” source

Solution

In Docker:

• Use Pipenv docker image as base so pipenv is correctly
• In your image, set working dir to where the src will eventually be clone to
• You need to set this as the working dir because of the way virtualenv names directories (see above). If you create it elsewhere and then try to copy it to the src directory it won’t work. More info here. You could simply reinstall every time but that slows things down considerably.
• Set PIPENV_VENV_IN_PROJECT=1 so virtualenv is created in project dir source
• Run pip install
• Move the .venv to a different folder so it’s not deleted when git clone happens

In Drone:

• Use our new image as base
• The default starting directory is root of my git repo
• `mv /app/.venv .` — this moves our pipenv dependencies into cloned folder
• `pipenv install — dev — deploy` install any dependencies that weren’t in our image already
• — deploy makes it so we get an error if the Pipfile.lock is out of date
• — dev just makes us install dev dependencies along with regular ones
• `pipenv run pytest` works great now
• To deploy to GAE:
• Create a requirements.txt from Pipfile source
• Deploy to GAE with those requirements

Thanks:

https://pythonspeed.com/articles/pipenv-docker/ — for some inspiration

Example Dockerfile.buildbox:

FROM kennethreitz/pipenv
WORKDIR /drone/src/github.com/my-org/my-repo
COPY Pipfile* ./
ENV PIPENV_VENV_IN_PROJECT=1
RUN pipenv install --dev --deploy
RUN mv .venv /app

Example .drone.yml

pipeline:

  run_core_tests:
    # the &buildbox_image of the line below creates a variable that we can call elsewhere with *buildbox_image
    image: &buildbox_image us.gcr.io/my-gcp-project/private-custom-build-env-image:somehash
    pull: &pull_enabled false #This is important so we don't accidentally get stuck with an old build image during dev
    commands: # These should be cleaned up into a build step and a test step
      - mv /app/.venv .
      # Dev makes it so we install dev dependencies
      # Deploy makes it so we will throw an error if Pipfile.lock is out of date (aka out of sync with Pipfile)
      # https://pipenv.readthedocs.io/en/latest/cli/#cmdoption-pipenv-install-d
      # Most dependencies should already be installed from the docker image, however, if we added some recently this ensures they'll be installed
      - pipenv install --dev --deploy
      # Verbose makes output a bit more readable
      # Capture=no allows us to see print statements
      # pythonwarnings allows us to hide the python warnings
      - pipenv run pytest --verbose --capture=no --pythonwarning=ignore
      # Now that the tests passed, lets make the requirements.txt in case we want to deploy to GAE
      # This needs to happen in the same block as pipenv install in case we have any new dependencies
      - ./tools/create_requirements.sh
    when:
      event: [push, tag]

If you go the game’s website from your desktop, you’ll get a message asking you to open it on mobile. Luckily, it’s easy enough to simulate a mobile device using the Google Chrome developer tools.

xdotool

Clicking a few thousand times using a tool like AutoHotkey would be easy. Unfortunately AutoHotKey is not available on linux, but there is an alternative: xdotool. With a few quick Google searches I was able to setup this bash script to start clicking for me. Within a few hours I was up to 60,000 clicks.

The next milestone was 300,000 clicks. I wanted to give it a shot to see what prizes laid behind such a massive number of clicks. Unfortunately, there were several downsides to the xdotool method:

• I could no longer use my computer
• It was relatively slow
• The browser would sometimes crash (likely due to the devtools storing a lot of info)

Websockets

When checking the network requests I found that the game wasn’t using regular HTTP requests but rather sending all the info through websockets. I had experience simulating HTTP requests but wasn’t sure how to go about simulating websocket frames.

First, I tried simulating a click on the screen using plain old javascript. After taking the code from this stackoverflow question, I was able to get the click event to dispatch but for some reason it wasn’t increasing the counter. Puzzled, I turned on the JS debugger just before firing the click event. Somewhere in the jumble of minified JS the script was checking if the click event was legit using the isTrusted property. Essentially, isTrusted is a security feature in browsers to see if the click was generated by the user or javascript. I didn’t find any simple way around it.

When digging through the JavaScript I got the idea to bypass the event handler and execute the code directly that was sending the message to the websocket. Between the minified code and my lack of familiarity with Websockets I couldn’t manage find the exact code that was sending the frame.

Next, I tried to find the Websocket object in memory to send frames myself using that. I had no luck finding the object in memory. What if I just make a new connection?

From what I could see, there were really only two kinds of frames being sent: one for authentication and a frame for each click event.

Authentication frame*:

420[“authenticate user”,{“username”:”raybb”,”token”:”ff45fb994e3124a5e0ce7bf7f27745dcbe62e71275532f982498b798",”squad”:””,”locale”:”en-gb”,”count”:62301,”csrf”:”0xsn5yq9SAb65OvTXDl3OjzRoVPgr1zVvDtzoVR4ZhjdptbHClRSVaSJDXKwXy8b”}]

Examples of the frames (1st, 2nd, and 10th)*:

421[“tap_logs”,{“username”:”raybb”,”timestamp”:1540163213460,”touchX”:19,”touchY”:78}]

422[“tap_logs”,{“username”:”raybb”,”timestamp”:1540163297196,”touchX”:389,”touchY”:737}]

4200[“tap_logs”,{“username”:”raybb”,”timestamp”:1540163347125,”touchX”:306,”touchY”:442}]

*these frames have modified values for privacy reasons.

From experimenting, I found:

• token and csrf: didn’t change between refreshes
• count: the number of taps I had when page loaded (changing it had no impact)
• The auth frame always started with 420 (which we shall call the frame counter)
• The frame counter mostly increased by 1
• The leftmost digits of the frame counter never reached 43. For example: [420, 421, 422, ..., 429, 4200, 4201, ..., 4299, 42000, ...]

With this in mind, I made my first attempt to simulate a click with a websocket:

const socket = new WebSocket('wss://socket-unlock.oneplus.com/socket.io/?EIO=3&transport=websocket');

socket.addEventListener('open', function(event {
   console.log("opened");
   socket.send(authFrame);
   socket.send(firstTap);
  });

It would connect successfully but the first tap wouldn’t send 🤔

It turns out that the server only accepts taps after it has sent a response confirming authentication. The confirmation frame always starts with 430 and contains your username. So all I had to do was wait for that frame to come back and then send my taps.

const socket = new WebSocket('wss://socket-unlock.oneplus.com/socket.io/?EIO=3&transport=websocket');

socket.addEventListener('open', function(event) {
 console.log("opened");
 socket.send(authFrame);
});

socket.addEventListener('message', function(event) {
 if (event.data.indexOf("raybb") > -1) {
  if (event.data.indexOf("430") > -1) {
   socket.send(firstTap);
  }
 }
});

After figuring that out, it was pretty easy to write the rest of the code. You can see the full script here.

The only issue with this method was that sending taps would eventually slow down. After sending a few thousand taps the script would get noticeably slower, and stay at that speed. I suspect it was due to the recursive nature of the script, which makes many layers of scoped variables to build. I changed the code to send 100 taps in each level of recursion. That seemed to help a bit but the slowing was still noticeable. Then I blocked all scripts from loading on the OnePlus website (so it was essentially just an empty page). That also seemed to help a bit.

I didn’t end up finding a solution to the slowing script. The contest was ending before too long. It wasn’t much of an issue and before I knew it I was on my way to 1 million taps. I may not have won any prizes from this but I did learn about click events, Websockets, xdotool, and a little more about poking through sites with the debugger.

Thanks for reading 🤓👏

In the first few hours I received hundreds of email notifications for PRs, comments, issues, and more. When I got home to find all these emails a quick Google Search showed that going to https://github.com/watching would allow you to see all the repos you were watching and unwatch them.

Many of my colleagues clicked the handy “Unwatch all” button on the top of the page. That wouldn’t work for me since I was watching several repos that I wanted the notifications from.

As such, I whipped up this handy little script to unwatch all the repos containing the organization name. All you have to do is paste it in the browser console and watch it do it’s magic! Fast forward to today, as I start working at the New York Times, and I found this script to be handy again. As such, I decided share it on here!

This summer hackNY expanded its commitment to the Summer of Good initiative by organizing several social good projects for fellows to contribute to outside of their internships. The goal of this initiative is to support nonprofit companies who have technologically-ambitious missions but lack the capacity to achieve them internally. It’s a perfect match between the Fellows and non-profits, since college interns are some of the only programmers on Earth willing to donate their late nights and weekends for months and these organizations are the only institutions willing to put college student volunteers in charge of entire mission-critical projects. While most of the organizations hackNY paired with were local to NYC, our team worked with Simprints, a startup based in Cambridge, UK. This is largely because Tristram, the CTO of Simprints, graduated from Eckerd College just a few years before me and I met him through a professor.

Simprints is a social enterprise that works with NGOs (non-governmental organizations) to provide identification services for recipients of aid. The problem these NGOs often face is that the communities they work with lack access to formal identification. This is due to a number of reasons including physical seclusion, inadequate government infrastructure, and political disenfranchisement. Over one billion people worldwide are ineligible to receive food, medicine, financial support, and other forms of aid because they can’t provide proof of their identity the way we can. Having grown up without many resources, the recipients often have no formal identification and only a rough idea of when they were born. To overcome this issue, Simprints has engineered a durable and low-cost fingerprint scanner alongside a simple, secure, open-source identification solution that can be integrated into existing digital services. Together, these two innovations offer an alternative to formal identification that can be deployed and managed locally.

Tristram Norman, co-founder and CTO, was our main point of contact with Simprints. Samad Arshad, a firmware developer at Simprint was also a huge help. Our team on the hackNY side consisted of Amber Rawson, Ben Yang, Clifford Lezark, and Raymond Berger.

Problem

At the time of writing, Simprints fingerprint scanners can only pair with Android phones. This has worked well for some organizations but other NGOs don’t have workflows that are compatible with android phones and, for various reasons, need to use a traditional computer instead. Our task was to come up with a solution for Simprints that would allow their scanner to connect to Bluetooth-enabled computers without the use of device-specific drivers.

Our Solution

We built a solution using Web Bluetooth, a wildly-underused API introduced by Google in 2015 that leveraged the modern browser’s flexibility to communicate with bluetooth devices. Using Web Bluetooth would be much easier than writing bluetooth drivers and having to support them across multiple operations systems and hardware configurations.

We quickly realized that this would be possible, but the application would only work on macOS and Chrome OS. Windows and Linux implementations of Web Bluetooth were much less developed and the API hadn’t been adopted by any other browsers. In theory we just needed to figure out the Web Bluetooth API and interface with the hardware, which had already been mailed to us. We knew that Web Bluetooth only supported BLE (Bluetooth Low Energy), and we knew the scanner had the hardware to support BLE but we just couldn’t make them connect. After a couple of hours spinning our wheels and talking with Tristram, we realized there was no BLE firmware developed for the scanner. We had to make our own.

Firmware

The challenge came from the thousand cuts we endured porting firmware written for a fifteen-year old standard to an eight-year old standard. Embedded programming can be complicated in part because it wrestles with hardware constraints. BLE adds more complication because it enforces further constraints in the interest of battery life and security. Vero’s firmware wasn’t built with those constraints in mind, so many aspects of it’s functionality had to be rewritten from the ground up. Rewriting the code for Vero wouldn’t have been too difficult if we had access to the source code for its proprietary Bluetooth stack at the outset of the project. A bluetooth stack, which in this case was graciously implemented for and licensed to Simprints free of charge, defines how firmware is written for a given device using a given protocol. However, no infrastructure for a BLE implementation of Vero’s firmware was provided so we needed to build it ourselves — boilerplate templates and all.

A month into the project we received an example of a BLE-ready project using the same Bluetooth stack. It allowed us to build a firmware with read/write functionality to ensure that the device could at least connect to our application, and enabled us to prototype the full firmware, but more problems developed. The stack’s compiler wouldn’t compile our code or tell us what problems it was facing, so we rebuilt the compiler. The compiled code needed to be built into firmware using equally confusing tools, so we had to learn how to use those tools. The amount of compatibility testing necessary before we could even load our prototype firmware onto the scanner threatened to take weeks to complete. Though we made a lot of progress, finishing the firmware would still take more time than we had. At the outset, we understood that embedded programming could be complicated and were prepared to work within the bounds of the hardware and software. What we weren’t prepared for was the complications imposed by the nature of the projects origin.

A redeeming takeaway is that all of our struggles were for a good reason — maintaining security for Simprints’ clients and the people they help. A defining feature of the Web Bluetooth API is the amount of attention afforded to security measures. With IoT security being such a pressing issue, the architects of Web Bluetooth chose to take precautions that are inherently difficult to work with but completely worthwhile. With sensitive biometric data passing over the air, ensuring its safe and secure movement across devices is worth the challenges.

Chrome Extension

While work with firmware development was ongoing we also worked on building a Google Chrome extension for Simprints. We decided that a chrome extension would be the best solution for a few reasons.

1. It would be easy to install and automatically update.
2. It is always visible in the browser, so it’s easy to access.
3. We could potentially inject the unique identifier into a clients website if needed.

From a technical standpoint the extension is rather simple. Essentially all we did was copy the Android app workflow and add a pretty coat of paint on top. To do this we used Vue.js and Bootstrap. Why Vue and Bootstrap? For a relatively small application they did the job well and are well documented. At this point, the extension doesn’t actually connect to the scanner due to the lack of firmware. However, it is a great way to show clients a possible new way to interface with the scanner. If they show enough interest, further resources will be put into developing the firmware and extension.

Thoughts on Volunteering

Generally speaking, non-profit organizations don’t come to mind often when most programmers think of innovative, life-changing careers. But as we discovered from working with SimPrints, some of the neatest work we had ever heard of is being done in this space. Non-profits are using Bluetooth in the browser to hook up biometric scanners in Bangladesh, creating tools that enable journalists to harness big data for their reporting, retooling government services to improve their workflow, and so much more. The opportunities available today in the non-profit space for tech workers are just as cutting-edge as anything being done in the private sector, and they also offer the chance to reap good karma and a good paycheck.

Web Bluetooth as a force for good with hackNY and Simprints was originally published in hackNY on Medium, where people are continuing the conversation by highlighting and responding to this story.