Cleaned up the home page

5 files changed, 35 insertions, 88 deletions

diff --git a/content/_index.md b/content/_index.md
index 6ae13bd..9521929 100644
--- a/content/_index.md
+++ b/content/_index.md
@@ -1,4 +1,6 @@
-# Hi! Welcome to my home on the internet
+# Welcome
+
+This is my home page on the world wide web. You can find information about my work, personal interests and contact information here.
 
 ![profile](profile.jpg)
 
@@ -14,6 +16,37 @@ My guiding principles in life are [Rationalism](https://en.wikipedia.org/wiki/Ra
 
 I enjoy sports, especially [badminton](https://badmintonnederland.toernooi.nl/player-profile/e76309d9-12b4-403e-b57c-39765194dd04) and have an on-again, off-again relationship with running. I also play snooker and chess on the wonderful [Lichess](https://lichess.org/@/KaranJayachandra) platform. My taste in music is mostly rock, metal and hip-hop. I am a self-taught campfire guitarist but hope to ditch the campfire title. I read both fiction and non-fiction titles when time permits. Authors that I like include Stephen King, John Grisham and Brandon Sanderson.
 
+I am a [Tamilian](https://en.wikipedia.org/wiki/Tamils) born in Hyderabad and brought up in Kolar. I am naturally inquisitive, an unapologetic sceptic and have a thirst for knowledge.
+
 ## The road so far
 
-I am a [Tamilian](https://en.wikipedia.org/wiki/Tamils) born in Hyderabad and brought up in Kolar. I am naturally inquisitive, an unapologetic sceptic and have a thirst for knowledge. My Alma mater includes Amrita University and TU Delft from where I got my bachelor's and master's degrees in electrical engineer respectively. I have worked as an intern in the Deference Research and Development Organization of India and as a consultant for SAP. I am currently working on the next generation of Automotive Radar systems for Adaptive Cruise Control, Lane Change Assist, Blind Spot Detection and Cross Traffic Alert at NXP Semiconductors.
+### NXP Semiconductors
+
+I am currently working on the next generation of Automotive Radar systems for Adaptive Cruise Control, Lane Change Assist, Blind Spot Detection and Cross Traffic Alert at NXP Semiconductors. My work at NXP includes:
+
+- System Design: Development and integration of algorithms into a signal processing chain to
+estimate radar target parameters across 3 generations of radar systems. End-to-end testing of
+the developed system using cutting-edge lab equipment and validation of the performance in
+outdoor scenarios. I have developed and tested several sensors that utilize signal processing algorithms.
+- Algorithm Design: I have developed algorithms individually and collaboratively, resulting in
+one patent and paper. I have verified the performance statistically using both simulations and
+data capture from internally developed radar sensors. These algorithms have been used to
+provide feedback to internal designers on future generations of NXP chips.
+- Infrastructure Development: I have been in charge of both the development of simulation and
+lab environments for the test of signal processing algorithms across the Signal Processing
+team in NXP. In this role, I have helped speed up and standardize the testing process across
+multiple teams and projects.
+
+### SAP India
+
+I worked as a software consultant for three years at SAP India Pvt. Ltd. As a consultant I worked with diverse teams both within India and globally and delivered successful projects across multiple domains. At my tenure in SAP, I learnt how to manage stakeholders and create value for my team and company. This lead to multiple awards in recognition of my contributions.
+
+### Defence Research and Development Organization
+
+As an intern at the Defence Research and Development organization, I worked in creating a method of uniquely identifying FPGA boards using the underlying silicon structure via ring oscillators. This work gave me an understanding of real world applications of some of the theoretical background I learnt at [Amrita](https://www.amrita.edu/).
+
+## What I have learnt
+
+My Alma mater includes [Amrita University](https://www.amrita.edu/) and [TU Delft](https://microelectronics.tudelft.nl/Education/bio.php?id=1176) from where I got my bachelor's and master's degrees in electrical engineer respectively. During my studies I have specialized in signal processing with a strong background in linear algebra, probability and statistics. I have taken up courses in Antenna Systems, Electromagnetics, Communication Theory, Remote Sensing and many more. Please feel free to have a look at my [CV](https://karanjayachandra.gitlab.io/cv) for more information.
+
+I am well versed in development in python and MATLAB with some experience in C programming and basic experience with FPGA development.
diff --git a/content/nano/_index.md b/content/nano/_index.md
deleted file mode 100644
index e69de29..0000000
--- a/content/nano/_index.md
+++ /dev/null
diff --git a/content/nano/high_frequency.md b/content/nano/high_frequency.md
deleted file mode 100644
index dc1fb93..0000000
--- a/content/nano/high_frequency.md
+++ /dev/null
@@ -1,12 +0,0 @@
-+++
-title = 'Low quality high frequency'
-date = "2024-12-02"
-+++
-
-# Low quality high frequency
-
-I have always enjoyed reading. My parents always encouraged my reading habit when I was a child and that stuck with me. With that came an appreciation of good writing. As an child brought up in rural India, I was above average when it came to writing for school. But as I grew up, I realized how woefully incompetent I was at. This was demotivating and resulted in me to stop trying. So for the last 10 years or so, I didn't put pen and paper together other for writing for work or school. All this changed recently. First, I turned 30 recently which was a wake up call of sorts. I suddenly didn't care anymore for if I was incompetent or not. All I wanted to say to myself when I was 40 was that I had given it an honest to god shot. Secondly, every time I saw good writing, I was envious. I was envious of how this author was always going to be better than me at something that I cared about.
-
-While thinking about this, I realized something. I play badminton and can call myself objectively an advanced player without hubris. The advice I would give to a person that just started without doubt would be to just start and play as much as possible. Ask the people who are better than you for advice and try to one up yourself everyday. Then it hit me, that these authors that were better than me at this skill would tell me the same thing. Come to think of it, this applies to anything that you would like to learn. So I have decided to start writing at least once a week for the rest of the year. The topic can be as vague and the article can be of shoddy quality. But the important thing is to put things out there.
-
-Therefore, I am going to use this 'nanoblog' of sorts to create posts that are writing exercises of sorts. They are mainly for myself and may not have much value for readers. But I would like to look back on this first article one day and say to myself, "Boy am I glad that I stuck to it and don't write like that anymore."
\ No newline at end of file
diff --git a/content/nano/package_flask.md b/content/nano/package_flask.md
deleted file mode 100644
index 12c2d06..0000000
--- a/content/nano/package_flask.md
+++ /dev/null
@@ -1,35 +0,0 @@
-+++
-title = 'Packaging Your Flask Application'
-date = "2024-12-25"
-+++
-
-# Packaging Your Flask Application
-
-A while ago, I was working on a hobby project for my Badminton Club, [The Smashing Fellows](https://www.bctsf.nl). The club meets twice a week, Tuesday and Friday. On Tuesday, we play using a system called the "Hussel" system which just means that the players are semi-randomly shuffled to create doubles matches amongst each other. The randomization allows for people to get to know each other while keeping also keeping things a bit competitive in terms of playing level. An archaic application written in Microsoft Access being used for this at the club started unravelling at the seams a few months ago. I volunteered to make a new application. The club didn't want the application to be able to run on Windows. I went down the Windows application development rabbit hole and ended deciding to not have anything to do with that. Since, I was already familiar with the use of Python, I ended up deciding to create a web application using Flask. The unique nature of this request didn't allow for deployment online with user information. Therefore, I ended up packaging the application into a wheel for easier deployment to run as a web server on the local machine. Usually, flask applications don't need to be packaged. They can be deployed as is. So, for people who might be in a similar situation, I am documenting the steps that I followed. I won't go into the details of how to create a package your python code or how to create a flask application. There are several tutorials for that. Here is how you combine.
-
-## Step 1: Add your static files into the package
-
-Add the static files that you plan to use into your package via the `pyproject.toml` file. This is usually done via the following lines:
-
-```bash
-[tool.setuptools.package-data]
-"templates" = ["*.j2"]
-"static" = ["*.css", "*.js"]
-```
-
-Here, I show an example which uses Jinja2 templates and some CSS and javascript files. This allows for the files you need for your application to run be accessible within the package and also adds it into wheel.
-
-## Step 2: Reference your files in the code
-
-Usually flask searches for the `static` and `templates` folder in the root directory from where you run the `app`. But since we have now moved this into the package directory, we would need to let flask where to find this. For this, we can provide the location of these folder when instantiating the `Flask` class with the arguments `static_folder` and `templates_folder` as shown below:
-
-```python
-from flask import Flask
-from importlib.resources import path
-
-app = Flask("<app_name>",
-            static_folder=path("<package_name>", "static"),
-            template_folder=path("<package_name>", "templates"))
-```
-
-Make sure to use the `importlib` package to locate where your package is installed. This allows for the path to be dynamically updated based on where the user installs your package. Now when you run your flask application you should be able to see the static files you need. In case you are interested in seeing the full code base, you can find it [here](https://gitlab.com/KaranJayachandra/match_up).
\ No newline at end of file
diff --git a/content/nano/python_scientific_computing.md b/content/nano/python_scientific_computing.md
deleted file mode 100644
index 4b7244a..0000000
--- a/content/nano/python_scientific_computing.md
+++ /dev/null
@@ -1,39 +0,0 @@
-+++
-title = 'Python for Scientific Computing'
-date = "2024-12-09"
-+++
-
-# Python for Scientific Computing
-I am a signal processing engineer and most of my work involves the creation of algorithms that make sense of data. I work with the data that is usually generated from an automotive radar but this necessarily doesn't have to be the case. For me, the data could be from any source but as long as there is information in the data, I can find a way to extract it. The complication that arises with my line of work comes from the fact that the data is usually [noisy](https://en.wikipedia.org/wiki/White_noise). Therefore, I end of doing quite a bit of statistical simulations to verify my work.
-
-Most engineers and scientists in my field work with MATLAB®. I however prefer to use Python. So if you are someone doing something similar to what I have just described, you might find this post useful. The following are some of the learnings from 2-3 years of consistent use of Python code scientific computing. This is of course a subjective account but I am free to discuss any of the points below via [email](mailto:mail@karanjayachandra.com).
-
-|![Filtering Noise](https://cdn.prod.website-files.com/5babb9f91ab233ff5f53ce10/608a88ee9c90126452af58d8_SMA-filtering.jpeg)| 
-|:--:|
-| *Filtering Noise (Source: [Catchpoint](https://www.catchpoint.com/blog/signal-vs-noise))* |
-
-## The don'ts
-I will start with a few don't that I believe are counter productive if you want to be good at scientific computing.
-
-### Don't reinvent the wheel
-If you are a software engineer, you can ignore this. But if you are trying to do signal processing, do not reinvent the wheel. Do not write your own `fourier_transform()` function. If you are learning to optimize the fourier transform or trying to understand it, by all means, go ahead. But most of the time, stealing someone else's implementation will be much more productive. Most importantly, your implementation will be slower. This will impact your simulation time. Learn to use [numpy](https://numpy.org/doc/2.1/index.html) and [scipy](https://scipy.org).
-
-### Don't use the latest version of Python
-Python is work in progress. Several versions of python exists and I have found that the sweet spot for the version to use is one lower than the latest. Most packages on PyPI will support it and you will not run into issues where a dependency of a dependency of your package is not supported by the latest version. Python is notoriously difficult at handling this.
-
-### Don't over engineer your code
-I have noticed that most of the code that actually helps make scientific conclusions can be achieved via very little. Keep your code and data simple. You don't need inheritance, you don't need that shiny new data structure. Keep to the basics and things will be much more easy to manage in the long run. It is not about how many lines of code but how few lines of code. Reduce the number of moving parts. A side note: If you are working with a team on a large project. Work on a smaller repository for your idea with a simplified test bench to prove your idea before shipping it to the larger system.
-
-## The do's
-
-### Use version control
-Even if you are the only person working on a project. Use git. This is crucial. If you want to work with other, it is doubly more important. git is not restricted to software projects but any text files that require frequent revision. Even this blog is under version control. Do not have 10 versions of your code floating around. Work on two branches, `main` and `develop` and keep them regularly in sync.
-
-### Use a virtual environment
-As mentioned earlier, python is known to be difficult to handle with respect to dependencies. Dependencies in python are both a boon and a curse. I find PyPI to be a democracy of sorts with the best package rising to the top for use. This allows for programmers to help each other out and reuse things. However, the version of package that you use might not be the same as the one installed on your colleagues machine. Therefore, for every git repository you have on your machine maintain a [venv](https://docs.python.org/3/library/venv.html). Maintain a `requirements.txt` file in the root folder so that others can easily install the dependencies needed for your code.
-
-### Automate the testing
-Most of the time, simulations require the generation of synthetic data or reading stored data and running it through your code. In my experience this is the most time consuming part of scientific computing. Learn to automate this and it will improve your workflow tremendously. Bonus points if you can make this work with git on pushes to the git server via [Jenkins](https://www.jenkins.io) some other automated testing platform.
-
-### Document the code
-At least, maintain a README.md for your repository. Explain briefly what you code does and how to install dependencies and run it. Start with this and when the experiment starts showing results, start maintain a more long form report containing the ins and outs of the code and the mathematics behind it. I prefer [LaTeX](https://www.latex-project.org) for its superior typesetting and ubiquity in academia. It also exports the same report as a HTML document which you can server as a static page along with your code.
\ No newline at end of file