<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LgQSBjJZASbUY71ieomCHA.jpeg"></figure><h4>I had the opportunity to complete scrum training and become a Certified Scrum Master. Here are my takeaways.</h4>
I’ve spent a long time working with pseudo-scrum, scrum-adjacent, or almost-scrum teams, but have never completed formal scrum training or certification. That changed this month! I had the opportunity to complete scrum training and become a Certified Scrum Master. Here are my takeaways.
<h3>#1: Scrum is a communication framework.</h3>
Scrum training reaffirmed one thing that I’ve always known about the framework: it involves a lot of meetings. In fact, almost every scrum ritual boils down to some kind of formalized conversation.
This may sound a bit reductionist, but it explains why scrum has been so successful for highly technical product teams. The vastly different skillsets (and personalities) on these teams typically lead to a communication barrier between those who want deliverables (business analysts, account managers, etc.) and those who deliver them (developers). It can be extremely difficult to organize and prioritize when business-oriented teams and developers don’t speak the same language. Rather than trying to dissolve this divide, scrum acknowledges it in the form of well-defined roles (e.g. ‘Product Owner’ and ‘Developer’). It then outlines rituals during which these team members communicate and act on critical information. For example, during the sprint planning ritual, the product owner is tasked with presenting the what and why of items being considered for development. The developers are responsible for discussing how these items will be implemented. This type of communication is much more effective because team members understand the goal of each meeting and the information that they are expected to bring to the table.
So, while scrum is still considered a product development framework, its roles and rituals show that bilateral communication is so critical to product development that the two have essentially become synonymous.
<h3>#2: Wait until you need scrum.</h3>
As the previous section illustrates, the scrum rituals combined can take a significant chunk of time out of your team’s week. For small, focused teams, it often doesn’t make sense to do anything other than build (I’ve long been a fan of controlled chaos). But when is it realistic to consider scrum?
According to the official scrum guide, the ideal size of a scrum team is 10 people. That allows for 1 product owner, 1 scrum master, and 8 developers. While this isn’t a strict rule, it illustrates the size of a team that will truly benefit from the structure that scrum provides.
In addition to the size of your team, you should also consider your company’s business model when deciding whether you’re ready for scrum. Scrum has been proven to excel when implemented at SAAS companies with a clear product focus. If the majority of your revenue comes from large, contract-based deals, project management may be better suited to your needs.
Again, there is no hard and fast rule for who can implement scrum and basic cost-benefit analysis can typically show you whether it’s worth it for your team.
In fact, scrum can even be a stepping stone in converting your business to a SAAS model if you’re not there yet — just make sure to communicate this to your customers!
<h3>#3: Simplify your tech stack.</h3>
<blockquote>Scrum Teams are cross-functional, meaning the members have all the skills necessary to create value each Sprint.</blockquote>
The above statement, from the official scrum guide, does not mean that every developer on a scrum team has to be full-stack. It simply means that teams must collectively have the skills to be productive every sprint.
After reading this I started to think about the easiest way to ensure that our team members (particularly developers) together possessed the knowledge and experience necessary to generate value. My conclusion: instead of putting the responsibility on developers to learn new skills, we should limit “all the skills” that need to be mastered. In other words, why not just simplify your tech stack to make it more accessible to the various members on your team?
Consider languages that are well supported, have an easier learning curve, and will allow you to build practically anything (JavaScript or TypeScript). Also vet various serverless tools (i.e. Lambda or Google Cloud Functions) that will allow you to scale without slowing your team down with maintenance costs.
In the same way that there is no firm requirement for who can implement scrum, there is no ideal tech stack. You know your team, your product, and the tools that will help them succeed.
<h3>#4 Good scrum is firm but flexible.</h3>
One of my big takeaways from scrum training was that it’s easy to look scrum-ish without following scrum at all. Unfortunately, labels like ‘product owner’, ‘scrum master’, and ‘sprint planning’ mean nothing unless they are backed by a commitment to follow the underlying process.
This doesn’t mean your team has to be the spitting image of the agile scrum guide. As our trainer pointed out, scrum should be firm but flexible. In fact, the process itself is meant to be continuously augmented in the same way as the deliverables it produces: in small, functional increments.
In other words, start as close to the scrum guide as you can. Rigidly define your team’s roles, rituals, expectations, and responsibilities. Then, starting at your first sprint retrospective, identify incremental changes that will improve the process and try them out. For example, you might try a new metric to gauge the size of development items. After a handful of iterations (5–6 sprints), you should start to feel scrum fitting to your teams nuances and unique requirements.
Ultimately, good scrum is a constantly evolving process that stays true to the scrum guide, but adapts to the changing needs of your team, your business, and your customers.
As a quick recap:
<ul>
<li>It can be helpful to think of scrum as a well-structured communication framework</li>
<li>Scrum isn’t for everybody and can cause more pain for companies/teams who aren’t ready for it.</li>
<li>Limit the number of skills your team has to master to be productive.</li>
<li>Continuously inspect and adapt your process to ensure your team gets the most out of scrum.</li>
</ul>
If you are implementing (successfully or unsuccessfully) scrum on your team, I’d love to talk to you! Drop me a note on <a href="https://www.garrettjester.com/">my website</a> and we can set up a time to chat.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=9cbb7b92f331" width="1" height="1" alt="">

Scrum Training in 4 Key Points

<figure><img alt="" src="https://cdn-images-1.medium.com/max/650/1*LTzKYVhf3yX27b1ft4CRLw.jpeg"><figcaption>Consume Apache Kafka Data with AWS Lambda</figcaption></figure>There are seemingly infinite things you can do with data once it’s in Kafka. You can stream data to an Elasticsearch index, process it with Kafka Streams, push it to a caching layer, or run it through a real-time ML Model on Apache Storm.
All of these possibilities can become overwhelming when you just want to trigger a simple action in response to a Kafka message (for example, you might want to notify a customer via email when the status of their order changes). Instead of creating our own Java applications to handle such a task, in this tutorial we’ll create a dead-simple Kafka consumer running Node.js on AWS Lambda. This is a template that can be used to handle one-off operations, like sending an alert via SendGrid or Twilio.
Prerequisites:
<ul>
<li>A running Kafka cluster (see <a href="https://garrett-jester.medium.com/build-a-real-time-backend-infrastructure-with-aws-msk-rds-ec2-and-debezium-1900c3ee5e67">previous article</a> for help with this)</li>
<li>An AWS Account with Console Access</li>
<li>IAM Permissions to Create a Lambda Function and provision a Lambda execution role</li>
</ul>
<h3>Verify VPC Configuration</h3>
The trickiest part of this process is ensuring that Lambda can read data from your Kafka Cluster. If you’ve deployed Kafka on MSK, AWS will typically place your broker instances in private subnets by default, which means they can’t be accessed by anything outside of your VPC (including Lambda functions).
The way around this is to create a public subnet that can communicate with your broker nodes (each in their own private subnet) via a NAT Gateway.
<blockquote>
Note: The only difference between a public and private subnet is that public subnets have an internet gateway, which, as it sounds, is a gateway to allow public internet traffic.</blockquote>
If you’ve followed my previous tutorial and already have an MSK cluster running, you can verify your cluster’s subnet configuration from the MSK dashboard:
<ol><li>Under networking, click on any of the subnets to go to the VPC management page.</li></ol>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/519/1*u-XfFEE9Tq9Sn0R4xxvFpA.png"></figure>2. Open the subnet of interest and click on Route Table.
If this is a private subnet (which it should be), you will not see an internet gateway listed under targets. If it’s a public subnet, you’ll see something like the following:
<figure><img alt="" src="https://cdn-images-1.medium.com/max/626/1*Zl0AlFMFCHa2urFBsTpCNg.png"><figcaption>IGW = internet gateway</figcaption></figure>3. Now that we’ve verified that the subnets for our Kafka cluster are private (no internet gateways), go to your VPC management dashboard and make sure you have public subnet in your Kafka cluster’s VPC (again, a public subnet’s route table will look like the image above).
4. Follow the steps to create a NAT Gateway in your VPC’s public subnet.
<blockquote>If you have any trouble creating the NAT Gateway, see the AWS-provided walkthrough <a href="https://aws.amazon.com/premiumsupport/knowledge-center/nat-gateway-vpc-private-subnet/">here</a>.</blockquote>
5. Finally, we’ll add the NAT gateway as a target for each of our private subnets used by MSK. You can navigate to them from the MSK dashboard under networking. For each private subnet, make sure that the route table lists the NAT Gateway as the target for all IPs. You can associate a new route table if necessary.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/610/1*FO6zoNBQISdEl8fcPkD0iQ.png"><figcaption>A private subnet’s route table configured to send data through a NAT Gateway.</figcaption></figure>You’re all set! Your MSK Cluster is ready to talk to Lambda. ✅
<blockquote>
Note: If you’re running self-managed Kafka on ECS or EC2, the subnet configuration will be the same, you just need to manually verify that each broker instance is deployed to the correct subnet.</blockquote>
<h3>Create a Lambda Execution Role</h3>
Now we have to ensure that Lambda has the permissions to read from MSK.
<ol>
<li>Go to the IAM Dashboard &gt; Roles &gt; Create Role
</li>
<li>Select ‘Lambda’ under use cases.</li>
<li>Attach the AWSMLambdaMSKExecutionRole to allow Lambda to read from MSK.</li>
<li>Create the role.</li>
</ol>
<h3>Create your Lambda Function</h3>
Head to the AWS Lambda Dashboard and we can now write your Kafka consumer app.
<ol>
<li>Click Create Function &gt; Author from scratch</li>
<li>Choose the latest Node.js runtime.
</li>
<li>Set the execution role to the one you created in the previous step.</li>
<li>Click Create Function.</li>
<li>Once your function has been deployed, under Function Overview click Add Trigger.</li>
<li>Select MSK from the dropdown and enter a Kafka topic that you can test with.</li>
<li>Set starting position to Latest and click Add.</li>
</ol>
<blockquote>
Note: If you’ve set up Kafka with Debezium, the auto-created topics follow the naming convention: DB_INSTANCE_NAME.public.TABLE_NAME</blockquote>
To verify that you can receive message from your Kafka cluster, add a console. log statement to the default event handler, send a message to the topic you chose to monitor, and check the function’s CloudWatch logs.
<blockquote>
Note: If you’re not seeing logs, you can click on the triggers tab to see if there are communication errors between MSK and Lambda. This is usually caused by a misconfigured MSK security group.</blockquote>
And that’s it! You can now write basic logic in Node.js to respond to events in Kafka. Adding the Twilio or SendGrid libraries for Node will let you send SMS messages or emails to your users in near real-time.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=52849c28d81d" width="1" height="1" alt=""><hr>
<a href="https://towardsaws.com/create-a-node-js-kafka-consumer-with-aws-lambda-52849c28d81d">Create a Node.js Kafka Consumer with AWS Lambda</a> was originally published in <a href="https://towardsaws.com/">Towards AWS</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.

Create a Node.js Kafka Consumer with AWS Lambda

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3vpYRxhUzwGMyV-yp0CfYg.jpeg"></figure><h3>Build a Powerful Backend with AWS (MSK + RDS + EC2) &amp; Debezium</h3>
In the time I’ve spent working with various startup and development teams, I’ve found that the most successful ones all tend to have mastered two things:
<ul>
<li>Robust, scalable database design — typically on PostgreSQL or MySQL
</li>
<li>Reliable PubSub messaging —typically using Apache Kafka
</li>
</ul>
These two fundamental pieces of your backend are at the crux of features like push notifications, search indexing, and caching. While database design and pubsub may seem straightforward in development, maintaining them at scale can be extremely frustrating and time consuming, especially for a small team.
The purpose of this tutorial is to show you how to configure and deploy a robust backend using AWS RDS for PostgreSQL, AWS MSK for Kafka and Debezium to connect the two. The best part about this configuration: it’s fully managed. This means you can scale to millions of users without having to worry about ugly things like DB replication or Kafka broker-level configs.
Prerequisites:
<ul>
<li>An AWS Account with Console and CLI Access</li>
<li>A SQL Client (I recommend the free version of <a href="https://www.dbvis.com/download/12.0">DB Visualizer</a>).</li>
<li>Beginner’s Understanding of SQL &amp; Linux Commands</li>
</ul>
<h3>Part I: Launch an MSK Cluster</h3>
An MSK Cluster can take about 25mins to become available (while AWS provisions all the necessary resources). Let’s get it launched so that it can be built in the background.
<h4>Build a Custom Kafka Configuration</h4>
Before we start, be aware that running a managed Kafka cluster can be pricey. We’ll build the cheapest option, which will cost about $30/month with burstable broker instances.
To start, we’ll use the AWS CLI (v2) to create a custom Kafka configuration called kafka-config. Start by creating a new file with the following options:
<pre>auto.create.topics.enable = true zookeeper.connection.timeout.ms = 1000</pre>
<blockquote>Note: If you’re using TextEdit on Mac, click Format &gt; Make Plain Text.</blockquote>
Now we’re going to use the file you just created to build a new MSK configuration on your AWS account:
<pre>aws kafka create-configuration --name “debezium-kafka-config” --description “MSK configuration for use with Debezium." --kafka-versions “2.3.1" --server-properties fileb://{PATH-TO-KAFKA-CONFIG}</pre>
You should get back a JSON response that includes the ARN of the config you just created.
<blockquote>Note: If the CLI complains that it can’t find your config file (even though the path is correct), you may be using a different version of the CLI. <a href="https://docs.aws.amazon.com/cli/latest/userguide/cliv2-migration.html#cliv2-migration-binaryparam">This link</a> should help you get around the issue.</blockquote>
<h4>Deploy a Kafka Cluster</h4>
Now that you have your configuration, head over to the MSK Dashboard (on the AWS Console) and we’ll launch a new Kafka cluster.
<ol>
<li>For creation method, choose Custom create.</li>
<li>Choose the AWS-recommended Kafka version.</li>
<li>Under ‘Configuration’, click Custom Configuration and select the config you just uploaded.</li>
<li>Keep the number of availability zones at 3 (recommended) and select 3 private subnets for each of your broker nodes.</li>
<li>Keep the default security group (we’ll edit this later).</li>
<li>For ‘Brokers’ scroll all the way down to the t3.kafka.small instances. (If you need higher throughput for a production workload, go with one of the m5 instance options.)</li>
<li>For development / testing purposes I recommend giving each of your broker nodes 30GiB of EBS storage. (Again, higher throughput workloads will require more, but this can always be auto-scaled).</li>
<li>Access control method: None.</li>
<li>Encryption: Check TLS &amp; Plaintext
</li>
<li>Choose Basic Monitoring (AWS charges extra for everything else 🥴)</li>
<li>Click Create Cluster.</li>
</ol>
Congrats — You just successfully built a fully-managed Kafka cluster. 🎉
<h3>Part II: Build a PostgreSQL DB on RDS</h3>
This section will walk you through setting up a low-cost PostgreSQL DB from scratch on RDS. If you already have a DB set up, skip to the Debezium configuration section.
<h4>Deploy a PostgreSQL DB</h4>
Navigate to the RDS Dashboard and click Create Database. Use the following configuration options :
<ol>
<li>Engine: PostgreSQL with the latest version (currently 12.5).</li>
<li>Template: Dev/Test
</li>
<li>Configure your credentials and store them somewhere safe (you’ll need them later).</li>
<li>Storage: General Purpose (SSD)
</li>
<li>Instance class: Burstable db.t3.small class.</li>
<li>Turn OFF auto-scaling storage. If the Debezium connector is misconfigured, it can eat up storage and cause your storage bill to increase linearly. See <a href="https://stackoverflow.com/questions/65409273/debezium-causes-postgres-to-run-out-of-disk-space-on-rds">this issue</a>. Once you’re confident your connector is properly configured, you can enable auto-scaling.</li>
<li>Standby Instance: No
</li>
<li>Public access: Yes
</li>
<li>Click Create Database.</li>
</ol>
Your DB will take a few minutes to become available.
<h4>Debezium Configuration</h4>
Now we’ll add configuration options to your DB instance so that it works with the Debezium connector.
<ol>
<li>Go to Parameter Groups from the RDS Dashboard and click Create Parameter Group.</li>
<li>Name this parameter group something like cdc-enabled-postgres, locate the option with the key rds.logical_replication and set the value to 1. Click Create Parameter Group.</li>
<li>If your DB instance status has transitioned to ‘available’, click Modify.</li>
<li>Scroll to Additional Configuration, set the initial database name to postgres and switch the parameter group to the one you just created.</li>
<li>Schedule the modifications to take effect immediately and click Modify Instance. Your instance state will transition to ‘Modifying’.</li>
<li>Once the instance is modified you’ll need to reboot it for the rds.logical_replication setting to update. Select your instance, then click Actions &gt; Reboot.</li>
</ol>
Next we need to access your DB instance from a SQL client to change user-level configurations for Debezium.
Go to your RDS instance and copy it’s endpoint:
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wz4vtzqwz151fLEfbKPdbw.png"></figure>Now, open a new DB connection via your SQL client. Enter the endpoint you copied as the host/server name and enter the DB credentials that you saved during creation.
<blockquote>
Note: If you have difficulty establishing a connection, make sure that your instance’s security group allows access from your IP address.</blockquote>
To verify that your wal_level property is set to logical by running the following command:
<pre>SHOW wal_level;</pre>
Now we’ll configure a postgres user with the required Debezium permissions:
<pre>CREATE role debezium WITH PASSWORD 'mypassword' login;</pre>
<pre>GRANT rds_superuser TO debezium; GRANT SELECT ON ALL TABLES IN SCHEMA public to debezium; GRANT CREATE ON DATABASE postgres TO debezium;</pre>
Finally, we need to configure a table to receive ‘heartbeat’ messages from Debezium. Heartbeat messages help solve a known issue with the Postgres connector which can cause the DB instance to run out of storage.
<pre>CREATE TABLE debezium_heartbeat (heartbeat VARCHAR NOT NULL)</pre>
<blockquote>Note: We’re granting the debezium user superuser access for development purposes, but you’ll likely want more fine-grained permissions in a production environment.</blockquote>
Your Postgres instance is now configured for use with Debezium ✅.
<h3>Part III: Build the Debezium Connector for Postgres</h3>
In the last step, we’ll put everything together by connecting our Postgres database to our Kafka cluster. To do this, we need to launch a client that will host Kafka Connect and the Debezium connector.
<h4>Deploy a Client Instance</h4>
One limitation of using MSK to manage a Kafka Cluster is that we can only access your cluster from within our VPC. This means that we need to launch an EC2 instance which will serve as our Kafka Client.
<ul>
<li>Deploy a t3.small EC2 instance with the latest Ubuntu image (you can use the Amazon Linux AMI, but some of the commands will differ). Ensure that its in the same VPC as your MSK Cluster.</li>
<li>Make note of the security group used when launching your instance.</li>
<li>SSH into your instance using the .pem key you downloaded at launch.</li>
</ul>
<h4>Install Kafka Connect</h4>
Run the following commands to install the confluent hub:
<pre>sudo apt-get update wget -qO - https://packages.confluent.io/deb/5.3/archive.key | sudo apt-key add -</pre>
<pre>sudo add-apt-repository "deb [arch=amd64] https://packages.confluent.io/deb/5.3 stable main"</pre>
<pre>sudo apt-get update &amp;&amp; sudo apt-get install confluent-hub-client confluent-common confluent-kafka-2.12</pre>
Click on Client Information from the dashboard of your MSK Cluster
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vvPLL6y2tDW3gWT-oVPQQg.png"></figure>Copy the Plaintext addresses of your bootstrap servers:
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nhtwfOTYOLJ-hQQ19OBSEw.png"></figure>Edit the Kafka Connect config. Paste the addresses from the previous step in for the bootstrap-servers option:
<pre>sudo nano /etc/kafka/connect-distributed.properties</pre>
<pre>bootstrap.servers=${COPIED_BOOTSTRAP_SERVER_ADDRESSES} group.id=debezium-cluster offset.storage.replication.factor=2 config.storage.replication.factor=2 status.storage.replication.factor=2 plugin.path=/usr/share/java,/usr/share/confluent-hub-components</pre>
<h4>Install the Debezium Connector</h4>
Add a .service file that can be used to start Kafka Connect:
<pre>sudo nano /lib/systemd/system/confluent-connect-distributed.service</pre>
<pre>[Unit] Description=Apache Kafka - connect-distributed Documentation=<a href="http://docs.confluent.io/">http://docs.confluent.io/</a> After=network.target</pre>
<pre>[Service] Type=simple User=cp-kafka Group=confluent ExecStart=/usr/bin/connect-distributed /etc/kafka/connect-distributed.properties TimeoutStopSec=180 Restart=no</pre>
<pre>[Install] WantedBy=multi-user.target</pre>
Now we’ll install the Debezium PostgreSQL Connector.
<pre>sudo confluent-hub install debezium/debezium-connector-postgresql:latest</pre>
And start Kafka Connect using systemctl:
<pre>systemctl enable confluent-connect-distributed systemctl start confluent-connect-distributed</pre>
Create a JSON config for the PostgreSQL connector:
<pre>nano postgres.json</pre>
<pre>{ "name": "debezium-pg-connector", "config": { "name": "debezium-pg-connector", "connector.class": "io.debezium.connector.postgresql.PostgresConnector", "database.server.id": "1", "tasks.max": "1", "slot.name": "debezium" "database.history.kafka.bootstrap.servers": [BOOTSTRAP_SERVERS] "database.server.name": "khyber", "database.dbname": "postgres", "database.hostname": [RDS_ENDPOINT], "database.port": "5432", "database.user": "debezium", "database.password": [MY_PASSWORD], "plugin.name": "pgoutput", "internal.key.converter.schemas.enable": "false", "transforms.unwrap.add.source.fields": "ts_ms", "key.converter.schemas.enable": "false", "internal.key.converter": "org.apache.kafka.connect.json.JsonConverter", "heartbeat.interval.ms": "30000", "heartbeat.action.query": "INSERT INTO debezium_heartbeat (heartbeat) VALUES ('thump')", "internal.value.converter.schemas.enable": "false", "value.converter.schemas.enable": "false", "internal.value.converter": "org.apache.kafka.connect.json.JsonConverter", "value.converter": "org.apache.kafka.connect.json.JsonConverter", "key.converter": "org.apache.kafka.connect.json.JsonConverter", "transforms": "unwrap", "transforms.unwrap.type": "io.debezium.transforms.ExtractNewRecordState" } }</pre>
Save your config file and then create your connector using the Confluent REST API:
<pre>curl -X POST -H “Accept: application/json” -H “Content-Type: application/json” <a href="http://localhost:8083/connectors">http://localhost:8083/connectors</a> -d @postgres.json</pre>
You can ensure that your connector is working properly by making a GET request for the connector’s status:
<pre>curl GET http://localhost:8083/connectors/debezium-pg-connector/status</pre>
It should return a response similar to the following:
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w5OkID9GZE7Ie0RvlT1bJQ.png"></figure>You’ve successfully built the Debezium connector for Postgres. Row level changes will now be sent directly into your Kafka cluster. ✅
And that’s it! You have a starter backend for a real-time application that can respond to any change made to your database.
<h3>Next Steps</h3>
Now that you can produce messages in Kafka (through the Debezium connector), you’ll probably want a way to consume them. There are a couple of ways to do this depending on your end goal:
<ul>
<li>For Search indexing, you can use Confluent’s pre-built <a href="https://docs.confluent.io/kafka-connect-elasticsearch/current/index.html">Elasticsearch Sink Connector</a>, which has good documentation and will automatically index your row-level changes.</li>
<li>For sending notifications to users, you’ll have to make some form of network request to a delivery service. I suggest following my other article, Consume Kafka Messages in Node.js with Lambda Functions, which will give you a bare-bones consumer to get you up and running.</li>
<li>If you’re a Java developer and you’re familiar with Apache Flink, you can use Flink’s Kafka Connector to process messages.</li>
</ul>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=1900c3ee5e67" width="1" height="1" alt="">

Recent Writing