<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Kyle Chin on Medium]]></title>
        <description><![CDATA[Stories by Kyle Chin on Medium]]></description>
        <link>https://medium.com/@kdchin?source=rss-eb872c1eeba1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*6E6qIZvnMdZGeI7AWmhBiw.png</url>
            <title>Stories by Kyle Chin on Medium</title>
            <link>https://medium.com/@kdchin?source=rss-eb872c1eeba1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 22:20:56 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kdchin/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Porting a Monolithic FHIR Datastore To a HAPI FHIR Microservice]]></title>
            <link>https://medium.com/curai-tech/porting-a-monolithic-fhir-datastore-to-a-hapi-fhir-microservice-945765c56ae3?source=rss-eb872c1eeba1------2</link>
            <guid isPermaLink="false">https://medium.com/p/945765c56ae3</guid>
            <category><![CDATA[healthcare]]></category>
            <category><![CDATA[fhir]]></category>
            <category><![CDATA[healthtech]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[startup]]></category>
            <dc:creator><![CDATA[Kyle Chin]]></dc:creator>
            <pubDate>Fri, 01 Oct 2021 17:15:12 GMT</pubDate>
            <atom:updated>2021-10-01T17:15:12.944Z</atom:updated>
            <content:encoded><![CDATA[<p>In this blog post, I’ll be detailing our journey in implementing a full <a href="https://www.hl7.org/fhir/overview.html">FHIR</a> server on top of our existing FHIR infrastructure. In a <a href="https://medium.com/curai-tech/longitudinal-care-a-fhir-side-chat-part-2-f74831a5ea68">previous blog post</a>, <a href="https://medium.com/u/b95b2f581061">Vignesh Venkataraman</a> detailed our initial FHIR implementation and I’d recommend giving that a read if you’re interested in the gory details. For reasons that I’ll detail fully in the next section, we needed to evolve our implementation into a fully-fledged FHIR server. At the end of this post, I’ll also go over the technical implementation of our HAPI FHIR server, and some learnings and next steps if you’re interested in building your own FHIR server from scratch!</p><h3><strong>Why we needed a change</strong></h3><p>Since our initial FHIR implementation, our need for additional FHIR support has proliferated — in order to unlock things like FHIR data quality testing and connecting to the Health Information Exchange (HIE), we needed more elements of a working FHIR server, especially since several desirable external systems like these utilize FHIR APIs to communicate. More importantly, as our team and codebase scales, we’ve been experiencing an increasing need to evolve our FHIR implementation past the initial infrastructure we initially implemented. In particular:</p><ol><li><strong>Our FHIR implementation was incomplete</strong> — intentionally so as to urgently unblock development, but still incomplete nonetheless. We were missing most of the <a href="https://www.hl7.org/fhir/http.html">operations</a> that a FHIR server typically supports, instead relying heavily on exactly three endpoints for all our FHIR-related interactions. We wanted the capability to both validate and extend our FHIR implementation <em>without having to build every piece from scratch ourselves</em>.</li><li><strong>Python FHIR support is limited</strong> — we were relying on the <a href="https://github.com/smart-on-fhir/client-py">SMART on FHIR python client-py library</a> for parsing FHIR resources to and from the database, but there is <a href="https://confluence.hl7.org/display/FHIR/Open+Source+Implementations">no complete FHIR implementation</a> library for python. Combined with <a href="https://github.com/smart-on-fhir/client-py/issues/70">some issues</a> with getting the library on R4, it became clear that we needed a solution that was easy to maintain as the FHIR standard and our use cases evolved. For instance, earlier this year I shipped a feature that integrated historical versioning for FHIR resources, which was a new use of FHIR that I had to build from scratch.</li><li><strong>FHIR had a large learning curve</strong> — our scrappy implementation left some tribal knowledge and a good bit of crufty code that made learning FHIR a taller task than it needed to be. Having a dedicated FHIR server forces a <em>decoupling</em> (a la microservices) of FHIR from our backend services, meaning not only will development be well-defined (by strictly interacting with FHIR through an API), but we will have dedicated engineering resources toward FHIR infrastructure and teamwide FHIR literacy. Finally, decoupling should allow us to integrate with external FHIR data sources down the road.</li></ol><h3><strong>Searching for a solution</strong></h3><p>It was a relatively short search. In addition to the considerations from above, we really valued:</p><ol><li>Ease of implementation and upkeep, since we are a small engineering team</li><li>Object oriented language, preferably Python or Java</li><li>Minimize (preferably eliminate) schema changes</li><li>In-house data hosting</li><li>Thorough documentation, active online community, and actively developed for the foreseeable future</li></ol><p><a href="https://hapifhir.io/">HAPI FHIR</a> checked all the boxes for us (particularly the <a href="https://hapifhir.io/hapi-fhir/docs/server_plain/introduction.html">Plain Server</a> implementation). In short, the plain server provides a structure by which the developer can implement the <a href="https://www.hl7.org/fhir/http.html">FHIR REST operations</a> on top of a pre-existing schema, and HAPI FHIR will handle wiring up the routes. In our case, we had an existing FHIR schema (detailed in a <a href="https://medium.com/curai-tech/longitudinal-care-a-fhir-side-chat-part-2-f74831a5ea68">previous blog post</a>), and we could build out the Java entities and HAPI FHIR infrastructure on top of that to get to a functional FHIR server. HAPI FHIR was perfect for us except that…</p><p>Our teamwide Java expertise was low, given that we had been developing our backend purely in Python since Curai’s inception. Compounding things, <strong>I could not find a single end-to-end, minimal HAPI FHIR implementation tutorial</strong>, which made it especially tough to get started. After a few weeks of Googling, coding, and cryptic errors, I was able to piece together several different tutorials to make a minimal example of a HAPI FHIR plain server. Obviously, our production implementation has a lot more bells and whistles, but these will vary from use case to use case so I think it’s most helpful to see a minimal example that you can eventually build on top of. When building your own server, three resources that I found particularly helpful are the <a href="http://community.fhir.org/">FHIR community board</a>, <a href="https://confluence.hl7.org/display/FHIR/Home">HL7 Confluence page</a>, and <a href="https://www.devdays.com/">DevDays presentations</a> from years prior.</p><h3><strong>Implementation</strong></h3><p>Before we jump into the code, below is a diagram of how each part of our FHIR infrastructure exists in our backend right now (simplified for the Patient FHIR resource type). The “<em>Python</em>” box is what our current FHIR systems operate on as described by Viggy in his <a href="https://medium.com/curai-tech/longitudinal-care-a-fhir-side-chat-part-2-f74831a5ea68">blog post</a>.The “<em>Java</em>” box is what we’re implementing in this tutorial. As shown, both are simultaneous consumers of the postgres table fhir_patient, at least until we migrate fully to HAPI FHIR (which will fully deprecate the “<em>Python</em>” box). Let’s get started with how to implement the “<em>Java</em>” box! Step-by-step instructions are below and the full code is <a href="https://github.com/curai/hapi-fhir-starter">here</a>!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/697/1*q8GB1qB91Q_DAUuWg5baew.png" /></figure><blockquote>Author’s note: for each step, please click on the (Code) link in the title to view the code changes required for each step before running the commands specified in the description!</blockquote><h4><strong>1. Setting up spring boot (</strong><a href="https://github.com/curai/hapi-fhir-starter/commit/8e892ec33e49c31e71ef9f2d03ecf6ec0e1095eb"><strong>Code</strong></a><strong>)</strong></h4><p>The first step to setting up our FHIR server is to set up a base Java webapp. To do this, head to <a href="https://start.spring.io/#!type=maven-project&amp;language=java&amp;platformVersion=2.5.1.RELEASE&amp;packaging=jar&amp;jvmVersion=11&amp;groupId=com.example&amp;artifactId=fhirserver&amp;name=fhirserver&amp;description=Demo%20project%20for%20Spring%20Boot&amp;packageName=com.example.fhirserver&amp;dependencies=data-jpa,web,h2">Spring Initializr</a> and add “Spring Data JPA”, “Spring Web”, and “H2 Database” (the link provided should have all of them already). Generate and download the bundle, and you have a base web server that can connect to a real H2 database. Later we will connect it to the real Postgres database.</p><figure><img alt="Spring initializr page" src="https://cdn-images-1.medium.com/max/1024/1*73ra2_NBmdOifNw0rkMNeA.png" /></figure><h4>2. Adding in HAPI (<a href="https://github.com/curai/hapi-fhir-starter/commit/a8961ecfaaea2800bd1d2c878e3f33232cea3f71">Code</a>)</h4><p>Now we’ll configure our Spring Boot server to work with HAPI FHIR’s server infrastructure. Note that HAPI FHIR’s REST API is configured differently than the typical Java Spring REST API routes, which is why we need to do this step.</p><p>Open up the project in IntelliJ (or your favorite Java IDE) and apply the code changes in the section title.</p><p>Running ./mvnw spring-boot:run from the project’s directory will pop up a server, and you should be able to download the server’s (empty) capabilities at localhost:8080/metadata. Right now, it should indicate that there are no actual capabilities supported because we haven’t implemented anything yet! If you’re getting an error, make sure you have a <a href="https://www.oracle.com/java/technologies/downloads/">JDK</a> installed!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/694/1*MIG7sLsxykMMdOvjEWdydw.png" /><figcaption>Empty server capabilities</figcaption></figure><h4>Passing around the HAPI FHIR Context (<a href="https://github.com/curai/hapi-fhir-starter/commit/b95275baaff3a06a4d9780682fc69a3df504de41">Code</a>)</h4><p>The HAPI FHIR Context is what we use to parse strings and bytes into Java objects (and back). It’s the core of HAPI FHIR, and we’ll need to use it in every piece of code that relates to HAPI FHIR. Since it is expensive to create, we want to create it just once, and access it from everywhere it is needed. Hence static methods!</p><h4>3. Creating a Patient Provider (<a href="https://github.com/curai/hapi-fhir-starter/commit/697b90c5c23bcac63a37ca3572fdf4d07fdf2103">Code</a>)</h4><p>Let’s make our FHIR server do something! In order to create an endpoint for a resource, we need to implement a <a href="https://hapifhir.io/hapi-fhir/docs/server_plain/resource_providers.html">provider</a> for the resource. Then, we need to create a method and annotate it with the appropriate <a href="https://hapifhir.io/hapi-fhir/docs/server_plain/rest_operations.html">HAPI FHIR decorator</a>. This will automatically configure the server to call that method when the route corresponding to the method is hit via the API.</p><p>Even though we’re not connected to a real database yet, we can still return some fake data to test our HAPI FHIR server. In this case, we’ll create a fake Patient and implement the read endpoint so we can view the patient.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/693/1*aggQ24-n3oQweRXw1JgFSw.png" /><figcaption>FHIR XML data for fake Patient Lord Farquaad</figcaption></figure><p>In this case, the @READ annotation configured a GET operation to the Patient endpoint by id, which is accessible at localhost:8080/Patient/1 (sub in any id — we just need a dummy one to trigger the read endpoint) and you should see an XML file with Lord Farquaad’s Patient data.</p><p>After applying the code, going back to localhost:8080/metadata, we should now see that the server supports Read for Patients. HAPI FHIR configured this automatically, and all future providers and methods will also be noted in this CapabilityStatement automatically.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9uumIi15kUlxUes-IIEjyQ.png" /><figcaption>Server capabilities now that we added in Patient READ</figcaption></figure><h4>4. Connecting Patient to the database</h4><h4>Adding in Postgres (<a href="https://github.com/curai/hapi-fhir-starter/commit/edc7b5f0fc837a16bce2e09c96f188a828ea3e00">Code</a>)</h4><p>Now that we know how to interact with the HAPI FHIR to get some dummy data, we can connect the API to an actual Postgres Database. You’ll need to create a local Postgres database with a username and password to supply to the application.properties config.</p><h4><strong>Supplying Patient Provider with actual data (</strong><a href="https://github.com/curai/hapi-fhir-starter/commit/0f71662c345ed34368624cb471bb52d1378df6af"><strong>Code</strong></a><strong>)</strong></h4><p>As noted in <a href="https://medium.com/curai-tech/longitudinal-care-a-fhir-side-chat-part-2-f74831a5ea68">Viggy’s FHIR post</a>, our FHIR data follows a schema where the entire resource is stored as a jsonb column. Create a fhir_patient table in the database with a jsonb column titled resource (and an id primary key column) and seed the table with a <a href="http://www.hl7.org/fhir/patient-examples.html">fake Patient JSON</a>.</p><p>We need to add in support for jsonb columns, since Hibernate (the Java ORM) does not support it natively — to do this, we’ll use a library called Hibernate-Types!</p><p>After applying this diff, when querying for the Patient resource at localhost:8080/Patient/1, you should get a serialization error. Why? The Java object serialized by Jackson (the default serializer for Hibernate) cannot be cast into a HAPI FHIR Patient instance. We need to configure the serializer to use the HAPI FHIR parser instead. Good thing we can use the HAPI FHIR context that we configured in step 2!</p><h4><strong>Adding in custom serialization and deserialization (</strong><a href="https://github.com/curai/hapi-fhir-starter/commit/9525e4fe1cd8f8add10beada91e90619fa2d9263"><strong>Code</strong></a><strong>)</strong></h4><p>With this, we tell Hibernate + Jackson to serialize/deserialize Patient types with the custom ObjectMapper that we provide. Going back to localhost:8080/Patient/1 should result in the exact JSON that you seeded the table with!</p><h3><strong>Next Steps</strong></h3><p>As I mentioned before, this is an intentionally barebones implementation of a FHIR server meant for you to customize to your own needs — we’re only supporting one operation for one resource, and the code isn’t very generic (it would be tedious to implement the 19 other resources that Curai currently uses). If you’re building your own FHIR server on top of this, here are some areas of work that we’ve built on top of this code:</p><ul><li>Implementing other resources and methods</li><li>Authorization and Authentication</li><li>Resource Validation</li><li>Integration with backend services as a microservice</li></ul><p>You may even see some of these as blog posts from us in the coming months!</p><h3><strong>Kyle’s Takeaways</strong></h3><ul><li>Current <a href="https://confluence.hl7.org/display/FHIR/Open+Source+Implementations?focusedCommentId=82912957">open-source FHIR infrastructure</a> is tightly coupled with programming language — making it tough to find a solution that completely satisfied our business and engineering needs (primarily python-based). As the health tech open source community grows, I would push for and expect this to change!</li><li>I would also push for more knowledge sharing regarding implementing FHIR infrastructure: both for technical nitty-gritty details and for more transparency and collaboration regarding specific best practices and technical decision making. As an inexperienced health tech developer, it was difficult to scour Google for videos, presentations, and articles to figure out both what I even needed to do, and then also how to implement that!</li><li>Strongly statically-typed languages like Java are fun :)</li></ul><p>If you found the contents of this blog post interesting, and / or are interested in working at a health tech company that dreams of changing the world and bringing the world’s best healthcare to every human being on the planet, Curai is hiring! Check out our careers page <a href="https://curaihealth.com/work">here</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=945765c56ae3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/curai-tech/porting-a-monolithic-fhir-datastore-to-a-hapi-fhir-microservice-945765c56ae3">Porting a Monolithic FHIR Datastore To a HAPI FHIR Microservice</a> was originally published in <a href="https://medium.com/curai-tech">Curai Health Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CMU Team 13: Our Experience at Terminal Live]]></title>
            <link>https://medium.com/terminal-player-strategies/cmu-team-13-our-experience-at-terminal-live-33d909647621?source=rss-eb872c1eeba1------2</link>
            <guid isPermaLink="false">https://medium.com/p/33d909647621</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[game-theory]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[carnegie-mellon]]></category>
            <dc:creator><![CDATA[Kyle Chin]]></dc:creator>
            <pubDate>Wed, 03 Apr 2019 22:57:16 GMT</pubDate>
            <atom:updated>2019-04-04T17:25:53.316Z</atom:updated>
            <content:encoded><![CDATA[<p>Hi, I’m Kyle Chin, and I’m writing on behalf of Austin Schick and Eric Clinch to detail our approach to the Terminal tower-defense game competition. We’re a trio of Carnegie Mellon University juniors and we had the opportunity to compete in Terminal Live at CMU a month ago. Although we got eliminated in the round of eight in the competition at CMU, we have since developed our strategy more and have reached 2nd on the global leaderboard, so I hope this will be an interesting and instructive read. Enjoy!</p><h3>Initial Approach</h3><p>After becoming acquainted with the Terminal game, we started designing a scalable and dynamic approach to the game, unlike static handcrafted strategies we had noticed in use. Although this approach comes with a large overhead cost and lower initial returns, we wanted to explore a new direction to approach the game (not to mention it’s more fun to do it this way!)</p><p>We modeled the game as a two-player zero-sum game, and chose our strategy according to the minimax principle. If you’re not familiar with minimax, you can read about it <a href="https://en.wikipedia.org/wiki/Minimax">here</a>. We defined a set of handcrafted strategies; for example, EMP’s escorted by Scramblers, or deploy nothing and save money. Using variations on these strategies, we simulated thousands of deployments for each player and played them against each other, and chose the deployment that maximized its security against all its opponents.</p><p>Intuitively, security as a metric means that a deployment is measured by its worst performance against any adversary. For example, if a deployment works very well on some opponents but performs very poorly against others, we considered this worse than a deployment that is competitive but unexceptional against all opponent algos.</p><p>To measure a deployment’s performance against an adversary in the security at runtime we generate deployments of our opponent (using their past deployments and random variations on them), simulate a round, and calculate the score of the board using utility function:</p><blockquote>U(board) = score(blue) * health(blue) − score(red) * health(red)</blockquote><p>We define the score function as:</p><blockquote>score(side) = bits + cores + D + S</blockquote><p>where D is the number of alive firewalls on the board and S is a measure of defensive deployment safety. S measures the defenders in place in the first and last 3 columns of the uppermost rows, and is higher if more defenses exist there. This is because that area is an exploitable area for attacks and must be defended in all cases.</p><h4>Simulator</h4><p>This strategy is great in theory, but the crux of it depends on the simulation of thousands of variations to choose the best option. So, in the week leading up to the competition, we spent many late nights designing and implementing a simulator in C++ optimized for performance so that we could run as many simulations as possible in the computing time allotted.</p><p>To maximize efficiency, we designed the data structures to support several optimizations. For one, since the pieces on the board are relatively sparsely distributed (especially attackers), we stored the coordinates of each piece in two places: each piece was stored in an auxiliary list and also on the board. This way, to execute procedures like moving, attacking, and shields, we could loop through this auxiliary list of pieces instead of searching over the entire board. This led to a lot of memory management issues that we had to iron out, but ended up leading to a hyper-fast simulator.</p><p>Another optimization was related to movement. Instead of finding movement paths on every iteration, we precomputed an information unit’s path at the beginning of the round, and only recomputed paths when a defending unit was removed from the board. This had a profound impact on simulation speed, boosting us from 24 simulations per second to over 380 simulations per second.</p><p>Our simulator ran as fast as any simulator we have seen on the forums (we saw one claiming 500 simulations per second, but that approximated certain parts of Terminal). Our production simulator ran 480 rounds per second (1,175 rounds in 2.5 seconds) with the only approximation being the encryption on an information unit.</p><p>Overall, most of our effort in the week leading up to the competition was spent building the simulator end-to-end, and we’re really proud of the result given the timeframe.</p><h3>Engineering Approach</h3><p>Our team faced a lot of challenges over the process. For one, of the three team members, only Eric had coded in C++ before which was a significant hurdle since our 3000+ line simulator was written exclusively in C++. It was certainly a challenge for Austin and I to learn the intricacies of the language on the fly, especially with the memory management challenges from our optimizations. We relied heavily on object-oriented programming to organize our code, which helped to break the simulator into more manageable pieces. Since the only accepted language submissions are Python, Rust, and Java, we also had to build a Python interpreter to interface with the C++ simulator.</p><p>To facilitate quick development, we created some tools that helped us along the way. One was an interface built using the Python GUI library Tkinter that would allow us to create deployments in the format our C++ code needed. This helped us quickly create the handcrafted strategies we needed for our strategies in addition to allowing us to easily test certain deployments on the simulator. Another tool we created was a REPL within the simulator so we could run the simulator step-by-step and examine pieces, allowing us to debug issues with appropriate granularity.</p><p>Finally, with regards to strategy development, we observed our strategy playing against opponents and adapted it based on the result. For example, in one game we noticed that we sent a lot of Scramblers in multiple turns that were extremely uneffective, so we adjusted our strategy to de-emphasize that strategy.</p><h3>Next steps &amp; Reflection</h3><p>After a disappointing finish in the CMU competition (top 8) we were determined to improve our strategy, and had noticed many ways of improving our algo (despite being ranked 72nd globally at this point).</p><p>For one, the frequency with which we deployed the impotent Scrambler strategy above was emblematic of an algo that played too scared. Maximizing security works well in sequential, turn-based games like chess or checkers, but since this was a simultaneous game, our algo was scared off alternative deployments that performed poorly against one or two random enemy deployments it encountered in simulation. Since Scramblers excel as defense-oriented information units, we realized that choosing to play them all the time was a generally a good protective measure (and therefore maximized security) but wasn’t a truly effective strategy. We shifted to an approach that maximized approximate security instead of absolute security and the Scrambler strategy was appropriately de-emphasized.</p><p>Additionally, we improved the intelligence with which we chose and simulated deployments to emulated a more game-theoretic approach. In addition, we shifted from modeling the game as a turn-based minimax game to a simultaneous approximate minimax game. We’ve also added variations on our defense strategy (as opposed to having just one maze strategy), and found a way to utilize replay data to improve our algo’s intelligence.</p><p>Despite these improvements, our algo was stuck around rank 40. To take it from there to the top 5, the biggest changes we made were actually bug-fixes within the simulator. Small things like testing attack phases and movement edge cases truly had a momentous impact on our algo’s performance. The biggest bug fix we made propelled us from rank 19 to rank 5. Turns out, small errors in our simulator had a huge impact on our algo’s performance. While our strategies were sound, they had been thrown off by inaccuracies in the simulator.</p><h3>Final Thoughts</h3><p>Overall, we’ve had a blast competing in this competition. We’ve learned a lot about large scale project development and organization (not to mention C++). The Terminal game is inherently different from many other games out there and we really had to be creative to design strategies that work well with it. We’re excited for the next month to improve our algo further and hopefully claim the top spot (watch out Ryan D). Thanks for reading!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=33d909647621" width="1" height="1" alt=""><hr><p><a href="https://medium.com/terminal-player-strategies/cmu-team-13-our-experience-at-terminal-live-33d909647621">CMU Team 13: Our Experience at Terminal Live</a> was originally published in <a href="https://medium.com/terminal-player-strategies">Terminal Player Strategies</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>